1 | // License: GPL. For details, see LICENSE file.
|
---|
2 | package org.openstreetmap.josm.gui.layer.gpx;
|
---|
3 |
|
---|
4 | import static org.openstreetmap.josm.tools.I18n.marktr;
|
---|
5 | import static org.openstreetmap.josm.tools.I18n.tr;
|
---|
6 |
|
---|
7 | import java.awt.AlphaComposite;
|
---|
8 | import java.awt.BasicStroke;
|
---|
9 | import java.awt.Color;
|
---|
10 | import java.awt.Composite;
|
---|
11 | import java.awt.Graphics2D;
|
---|
12 | import java.awt.LinearGradientPaint;
|
---|
13 | import java.awt.MultipleGradientPaint;
|
---|
14 | import java.awt.Paint;
|
---|
15 | import java.awt.Point;
|
---|
16 | import java.awt.Rectangle;
|
---|
17 | import java.awt.RenderingHints;
|
---|
18 | import java.awt.Stroke;
|
---|
19 | import java.awt.image.BufferedImage;
|
---|
20 | import java.awt.image.DataBufferInt;
|
---|
21 | import java.awt.image.Raster;
|
---|
22 | import java.io.BufferedReader;
|
---|
23 | import java.io.IOException;
|
---|
24 | import java.util.ArrayList;
|
---|
25 | import java.util.Arrays;
|
---|
26 | import java.util.Collection;
|
---|
27 | import java.util.Collections;
|
---|
28 | import java.util.Date;
|
---|
29 | import java.util.List;
|
---|
30 |
|
---|
31 | import org.openstreetmap.josm.Main;
|
---|
32 | import org.openstreetmap.josm.data.SystemOfMeasurement;
|
---|
33 | import org.openstreetmap.josm.data.SystemOfMeasurement.SoMChangeListener;
|
---|
34 | import org.openstreetmap.josm.data.coor.LatLon;
|
---|
35 | import org.openstreetmap.josm.data.gpx.GpxConstants;
|
---|
36 | import org.openstreetmap.josm.data.gpx.GpxData;
|
---|
37 | import org.openstreetmap.josm.data.gpx.WayPoint;
|
---|
38 | import org.openstreetmap.josm.data.preferences.AbstractProperty;
|
---|
39 | import org.openstreetmap.josm.data.preferences.ColorProperty;
|
---|
40 | import org.openstreetmap.josm.gui.MapView;
|
---|
41 | import org.openstreetmap.josm.io.CachedFile;
|
---|
42 | import org.openstreetmap.josm.tools.ColorScale;
|
---|
43 | import org.openstreetmap.josm.tools.JosmRuntimeException;
|
---|
44 | import org.openstreetmap.josm.tools.Utils;
|
---|
45 |
|
---|
46 | /**
|
---|
47 | * Class that helps to draw large set of GPS tracks with different colors and options
|
---|
48 | * @since 7319
|
---|
49 | */
|
---|
50 | public class GpxDrawHelper implements SoMChangeListener {
|
---|
51 |
|
---|
52 | /**
|
---|
53 | * The color that is used for drawing GPX points.
|
---|
54 | * @since 10824
|
---|
55 | */
|
---|
56 | public static final ColorProperty DEFAULT_COLOR = new ColorProperty(marktr("gps point"), Color.magenta);
|
---|
57 |
|
---|
58 | private final GpxData data;
|
---|
59 |
|
---|
60 | // draw lines between points belonging to different segments
|
---|
61 | private boolean forceLines;
|
---|
62 | // use alpha blending for line draw
|
---|
63 | private boolean alphaLines;
|
---|
64 | // draw direction arrows on the lines
|
---|
65 | private boolean direction;
|
---|
66 | /** width of line for paint **/
|
---|
67 | private int lineWidth;
|
---|
68 | /** don't draw lines if longer than x meters **/
|
---|
69 | private int maxLineLength;
|
---|
70 | // draw lines
|
---|
71 | private boolean lines;
|
---|
72 | /** paint large dots for points **/
|
---|
73 | private boolean large;
|
---|
74 | private int largesize;
|
---|
75 | private boolean hdopCircle;
|
---|
76 | /** paint direction arrow with alternate math. may be faster **/
|
---|
77 | private boolean alternateDirection;
|
---|
78 | /** don't draw arrows nearer to each other than this **/
|
---|
79 | private int delta;
|
---|
80 | private double minTrackDurationForTimeColoring;
|
---|
81 |
|
---|
82 | /** maximum value of displayed HDOP, minimum is 0 */
|
---|
83 | private int hdoprange;
|
---|
84 |
|
---|
85 | private static final double PHI = Math.toRadians(15);
|
---|
86 |
|
---|
87 | //// Variables used only to check cache validity
|
---|
88 | private boolean computeCacheInSync;
|
---|
89 | private int computeCacheMaxLineLengthUsed;
|
---|
90 | private Color computeCacheColorUsed;
|
---|
91 | private boolean computeCacheColorDynamic;
|
---|
92 | private ColorMode computeCacheColored;
|
---|
93 | private int computeCacheColorTracksTune;
|
---|
94 | private int computeCacheHeatMapDrawColorTableIdx;
|
---|
95 |
|
---|
96 | //// Color-related fields
|
---|
97 | /** Mode of the line coloring **/
|
---|
98 | private ColorMode colored;
|
---|
99 | /** max speed for coloring - allows to tweak line coloring for different speed levels. **/
|
---|
100 | private int colorTracksTune;
|
---|
101 | private boolean colorModeDynamic;
|
---|
102 | private Color neutralColor;
|
---|
103 | private int largePointAlpha;
|
---|
104 |
|
---|
105 | // default access is used to allow changing from plugins
|
---|
106 | private ColorScale velocityScale;
|
---|
107 | /** Colors (without custom alpha channel, if given) for HDOP painting. **/
|
---|
108 | private ColorScale hdopScale;
|
---|
109 | private ColorScale dateScale;
|
---|
110 | private ColorScale directionScale;
|
---|
111 |
|
---|
112 | /** Opacity for hdop points **/
|
---|
113 | private int hdopAlpha;
|
---|
114 |
|
---|
115 | // lookup array to draw arrows without doing any math
|
---|
116 | private static final int ll0 = 9;
|
---|
117 | private static final int sl4 = 5;
|
---|
118 | private static final int sl9 = 3;
|
---|
119 | private static final int[][] dir = {
|
---|
120 | {+sl4, +ll0, +ll0, +sl4}, {-sl9, +ll0, +sl9, +ll0},
|
---|
121 | {-ll0, +sl4, -sl4, +ll0}, {-ll0, -sl9, -ll0, +sl9},
|
---|
122 | {-sl4, -ll0, -ll0, -sl4}, {+sl9, -ll0, -sl9, -ll0},
|
---|
123 | {+ll0, -sl4, +sl4, -ll0}, {+ll0, +sl9, +ll0, -sl9}
|
---|
124 | };
|
---|
125 |
|
---|
126 | /** heat map parameters **/
|
---|
127 |
|
---|
128 | // enabled or not (override by settings)
|
---|
129 | private boolean heatMapEnabled;
|
---|
130 | // draw small extra line
|
---|
131 | private boolean heatMapDrawExtraLine;
|
---|
132 | // used index for color table (parameter)
|
---|
133 | private int heatMapDrawColorTableIdx;
|
---|
134 |
|
---|
135 | // normal buffered image and draw object (cached)
|
---|
136 | private BufferedImage heatMapImgGray;
|
---|
137 | private Graphics2D heatMapGraph2d;
|
---|
138 |
|
---|
139 | // some cached values
|
---|
140 | Rectangle heatMapCacheScreenBounds = new Rectangle();
|
---|
141 | int heatMapCacheVisibleSegments;
|
---|
142 | double heatMapCacheZoomScale;
|
---|
143 | int heatMapCacheLineWith;
|
---|
144 |
|
---|
145 | // copied value for line drawing
|
---|
146 | private final List<Integer> heatMapPolyX = new ArrayList<>();
|
---|
147 | private final List<Integer> heatMapPolyY = new ArrayList<>();
|
---|
148 |
|
---|
149 | // setup color maps used by heat map
|
---|
150 | private static Color[] heatMapLutColorJosmInferno = createColorFromResource("inferno");
|
---|
151 | private static Color[] heatMapLutColorJosmViridis = createColorFromResource("viridis");
|
---|
152 | private static Color[] heatMapLutColorJosmBrown2Green = createColorFromResource("brown2green");
|
---|
153 | private static Color[] heatMapLutColorJosmRed2Blue = createColorFromResource("red2blue");
|
---|
154 |
|
---|
155 | // user defined heatmap color
|
---|
156 | private Color[] heatMapLutUserColor = createColorLut(Color.BLACK, Color.WHITE);
|
---|
157 |
|
---|
158 | // heat map color in use
|
---|
159 | private Color[] heatMapLutColor;
|
---|
160 |
|
---|
161 | private void setupColors() {
|
---|
162 | hdopAlpha = Main.pref.getInteger("hdop.color.alpha", -1);
|
---|
163 | velocityScale = ColorScale.createHSBScale(256);
|
---|
164 | /** Colors (without custom alpha channel, if given) for HDOP painting. **/
|
---|
165 | hdopScale = ColorScale.createHSBScale(256).makeReversed().addTitle(tr("HDOP"));
|
---|
166 | dateScale = ColorScale.createHSBScale(256).addTitle(tr("Time"));
|
---|
167 | directionScale = ColorScale.createCyclicScale(256).setIntervalCount(4).addTitle(tr("Direction"));
|
---|
168 | heatMapLutColor = heatMapLutUserColor;
|
---|
169 |
|
---|
170 | systemOfMeasurementChanged(null, null);
|
---|
171 | }
|
---|
172 |
|
---|
173 | @Override
|
---|
174 | public void systemOfMeasurementChanged(String oldSoM, String newSoM) {
|
---|
175 | SystemOfMeasurement som = SystemOfMeasurement.getSystemOfMeasurement();
|
---|
176 | velocityScale.addTitle(tr("Velocity, {0}", som.speedName));
|
---|
177 | if (oldSoM != null && newSoM != null && Main.isDisplayingMapView()) {
|
---|
178 | Main.map.mapView.repaint();
|
---|
179 | }
|
---|
180 | }
|
---|
181 |
|
---|
182 | /**
|
---|
183 | * Different color modes
|
---|
184 | */
|
---|
185 | public enum ColorMode {
|
---|
186 | NONE, VELOCITY, HDOP, DIRECTION, TIME, HEATMAP;
|
---|
187 |
|
---|
188 | static ColorMode fromIndex(final int index) {
|
---|
189 | return values()[index];
|
---|
190 | }
|
---|
191 |
|
---|
192 | int toIndex() {
|
---|
193 | return Arrays.asList(values()).indexOf(this);
|
---|
194 | }
|
---|
195 | }
|
---|
196 |
|
---|
197 | /**
|
---|
198 | * Constructs a new {@code GpxDrawHelper}.
|
---|
199 | * @param gpxData GPX data
|
---|
200 | * @param abstractProperty The color to draw with
|
---|
201 | * @since 10824
|
---|
202 | */
|
---|
203 | public GpxDrawHelper(GpxData gpxData, AbstractProperty<Color> abstractProperty) {
|
---|
204 | data = gpxData;
|
---|
205 | setupColors();
|
---|
206 | }
|
---|
207 |
|
---|
208 | private static String specName(String layerName) {
|
---|
209 | return "layer " + layerName;
|
---|
210 | }
|
---|
211 |
|
---|
212 | /**
|
---|
213 | * Get the default color for gps tracks for specified layer
|
---|
214 | * @param layerName name of the GpxLayer
|
---|
215 | * @param ignoreCustom do not use preferences
|
---|
216 | * @return the color or null if the color is not constant
|
---|
217 | */
|
---|
218 | public Color getColor(String layerName, boolean ignoreCustom) {
|
---|
219 | if (ignoreCustom || getColorMode(layerName) == ColorMode.NONE) {
|
---|
220 | return DEFAULT_COLOR.getChildColor(specName(layerName)).get();
|
---|
221 | } else {
|
---|
222 | return null;
|
---|
223 | }
|
---|
224 | }
|
---|
225 |
|
---|
226 | /**
|
---|
227 | * Read coloring mode for specified layer from preferences
|
---|
228 | * @param layerName name of the GpxLayer
|
---|
229 | * @return coloring mode
|
---|
230 | */
|
---|
231 | public ColorMode getColorMode(String layerName) {
|
---|
232 | try {
|
---|
233 | int i = Main.pref.getInteger("draw.rawgps.colors", specName(layerName), 0);
|
---|
234 | return ColorMode.fromIndex(i);
|
---|
235 | } catch (IndexOutOfBoundsException e) {
|
---|
236 | Main.warn(e);
|
---|
237 | }
|
---|
238 | return ColorMode.NONE;
|
---|
239 | }
|
---|
240 |
|
---|
241 | /** Reads generic color from preferences (usually gray)
|
---|
242 | * @return the color
|
---|
243 | **/
|
---|
244 | public static Color getGenericColor() {
|
---|
245 | return DEFAULT_COLOR.get();
|
---|
246 | }
|
---|
247 |
|
---|
248 | /**
|
---|
249 | * Read all drawing-related settings from preferences
|
---|
250 | * @param layerName layer name used to access its specific preferences
|
---|
251 | **/
|
---|
252 | public void readPreferences(String layerName) {
|
---|
253 | String spec = specName(layerName);
|
---|
254 | forceLines = Main.pref.getBoolean("draw.rawgps.lines.force", spec, false);
|
---|
255 | direction = Main.pref.getBoolean("draw.rawgps.direction", spec, false);
|
---|
256 | lineWidth = Main.pref.getInteger("draw.rawgps.linewidth", spec, 0);
|
---|
257 | alphaLines = Main.pref.getBoolean("draw.rawgps.lines.alpha-blend", spec, false);
|
---|
258 |
|
---|
259 | if (!data.fromServer) {
|
---|
260 | maxLineLength = Main.pref.getInteger("draw.rawgps.max-line-length.local", spec, -1);
|
---|
261 | lines = Main.pref.getBoolean("draw.rawgps.lines.local", spec, true);
|
---|
262 | } else {
|
---|
263 | maxLineLength = Main.pref.getInteger("draw.rawgps.max-line-length", spec, 200);
|
---|
264 | lines = Main.pref.getBoolean("draw.rawgps.lines", spec, true);
|
---|
265 | }
|
---|
266 | large = Main.pref.getBoolean("draw.rawgps.large", spec, false);
|
---|
267 | largesize = Main.pref.getInteger("draw.rawgps.large.size", spec, 3);
|
---|
268 | hdopCircle = Main.pref.getBoolean("draw.rawgps.hdopcircle", spec, false);
|
---|
269 | colored = getColorMode(layerName);
|
---|
270 | alternateDirection = Main.pref.getBoolean("draw.rawgps.alternatedirection", spec, false);
|
---|
271 | delta = Main.pref.getInteger("draw.rawgps.min-arrow-distance", spec, 40);
|
---|
272 | colorTracksTune = Main.pref.getInteger("draw.rawgps.colorTracksTune", spec, 45);
|
---|
273 | colorModeDynamic = Main.pref.getBoolean("draw.rawgps.colors.dynamic", spec, false);
|
---|
274 | /* good HDOP's are between 1 and 3, very bad HDOP's go into 3 digit values */
|
---|
275 | hdoprange = Main.pref.getInteger("hdop.range", 7);
|
---|
276 | minTrackDurationForTimeColoring = Main.pref.getInteger("draw.rawgps.date-coloring-min-dt", 60);
|
---|
277 | largePointAlpha = Main.pref.getInteger("draw.rawgps.large.alpha", -1) & 0xFF;
|
---|
278 |
|
---|
279 | // get heatmap parameters
|
---|
280 | heatMapEnabled = Main.pref.getBoolean("draw.rawgps.heatmap.enabled", spec, false);
|
---|
281 | heatMapDrawExtraLine = Main.pref.getBoolean("draw.rawgps.heatmap.line-extra", spec, false);
|
---|
282 | heatMapDrawColorTableIdx = Main.pref.getInteger("draw.rawgps.heatmap.colormap", specName(layerName), 0);
|
---|
283 |
|
---|
284 | neutralColor = getColor(layerName, true);
|
---|
285 | velocityScale.setNoDataColor(neutralColor);
|
---|
286 | dateScale.setNoDataColor(neutralColor);
|
---|
287 | hdopScale.setNoDataColor(neutralColor);
|
---|
288 | directionScale.setNoDataColor(neutralColor);
|
---|
289 |
|
---|
290 | largesize += lineWidth;
|
---|
291 | }
|
---|
292 |
|
---|
293 | /**
|
---|
294 | * Draw all enabled GPX elements of layer.
|
---|
295 | * @param g the common draw object to use
|
---|
296 | * @param mv the meta data to current displayed area
|
---|
297 | * @param visibleSegments segments visible in the current scope of mv
|
---|
298 | */
|
---|
299 | public void drawAll(Graphics2D g, MapView mv, List<WayPoint> visibleSegments) {
|
---|
300 |
|
---|
301 | final long timeStart = System.currentTimeMillis();
|
---|
302 |
|
---|
303 | checkCache();
|
---|
304 |
|
---|
305 | // STEP 2b - RE-COMPUTE CACHE DATA *********************
|
---|
306 | if (!computeCacheInSync) { // don't compute if the cache is good
|
---|
307 | calculateColors();
|
---|
308 | }
|
---|
309 |
|
---|
310 | fixColors(visibleSegments);
|
---|
311 |
|
---|
312 | // backup the environment
|
---|
313 | Composite oldComposite = g.getComposite();
|
---|
314 | Stroke oldStroke = g.getStroke();
|
---|
315 | Paint oldPaint = g.getPaint();
|
---|
316 |
|
---|
317 | // set hints for the render
|
---|
318 | g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
|
---|
319 | Main.pref.getBoolean("mappaint.gpx.use-antialiasing", false) ?
|
---|
320 | RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF);
|
---|
321 |
|
---|
322 | if (lineWidth != 0) {
|
---|
323 | g.setStroke(new BasicStroke(lineWidth, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
|
---|
324 | }
|
---|
325 |
|
---|
326 | // global enabled or select via color
|
---|
327 | boolean useHeatMap = heatMapEnabled || ColorMode.HEATMAP == colored;
|
---|
328 |
|
---|
329 | // default global alpha level
|
---|
330 | float layerAlpha = 1.00f;
|
---|
331 |
|
---|
332 | // extract current alpha blending value
|
---|
333 | if (oldComposite instanceof AlphaComposite) {
|
---|
334 | layerAlpha = ((AlphaComposite) oldComposite).getAlpha();
|
---|
335 | }
|
---|
336 |
|
---|
337 | // use heatmap background layer
|
---|
338 | if (useHeatMap) {
|
---|
339 | drawHeatMap(g, mv, visibleSegments);
|
---|
340 | } else {
|
---|
341 | // use normal line style or alpha-blending lines
|
---|
342 | if (!alphaLines) {
|
---|
343 | drawLines(g, mv, visibleSegments);
|
---|
344 | } else {
|
---|
345 | drawLinesAlpha(g, mv, visibleSegments, layerAlpha);
|
---|
346 | }
|
---|
347 | }
|
---|
348 |
|
---|
349 | // override global alpha settings (smooth overlay)
|
---|
350 | if (alphaLines || useHeatMap) {
|
---|
351 | g.setComposite(AlphaComposite.SrcOver.derive(0.25f * layerAlpha));
|
---|
352 | }
|
---|
353 |
|
---|
354 | // normal overlays
|
---|
355 | drawArrows(g, mv, visibleSegments);
|
---|
356 | drawPoints(g, mv, visibleSegments);
|
---|
357 |
|
---|
358 | // restore environment
|
---|
359 | g.setPaint(oldPaint);
|
---|
360 | g.setStroke(oldStroke);
|
---|
361 | g.setComposite(oldComposite);
|
---|
362 |
|
---|
363 | // show some debug info
|
---|
364 | if (Main.isDebugEnabled() && !visibleSegments.isEmpty()) {
|
---|
365 | final long timeDiff = System.currentTimeMillis() - timeStart;
|
---|
366 |
|
---|
367 | Main.debug("gpxdraw::draw takes " +
|
---|
368 | Utils.getDurationString(timeDiff) +
|
---|
369 | "(" +
|
---|
370 | "segments= " + visibleSegments.size() +
|
---|
371 | ", per 10000 = " + Utils.getDurationString(10_000 * timeDiff / visibleSegments.size()) +
|
---|
372 | ")"
|
---|
373 | );
|
---|
374 | }
|
---|
375 | }
|
---|
376 |
|
---|
377 | /**
|
---|
378 | * Calculate colors of way segments based on latest configuration settings
|
---|
379 | */
|
---|
380 | public void calculateColors() {
|
---|
381 | double minval = +1e10;
|
---|
382 | double maxval = -1e10;
|
---|
383 | WayPoint oldWp = null;
|
---|
384 |
|
---|
385 | if (colorModeDynamic) {
|
---|
386 | if (colored == ColorMode.VELOCITY) {
|
---|
387 | final List<Double> velocities = new ArrayList<>();
|
---|
388 | for (Collection<WayPoint> segment : data.getLinesIterable(null)) {
|
---|
389 | if (!forceLines) {
|
---|
390 | oldWp = null;
|
---|
391 | }
|
---|
392 | for (WayPoint trkPnt : segment) {
|
---|
393 | LatLon c = trkPnt.getCoor();
|
---|
394 | if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
|
---|
395 | continue;
|
---|
396 | }
|
---|
397 | if (oldWp != null && trkPnt.time > oldWp.time) {
|
---|
398 | double vel = c.greatCircleDistance(oldWp.getCoor())
|
---|
399 | / (trkPnt.time - oldWp.time);
|
---|
400 | velocities.add(vel);
|
---|
401 | }
|
---|
402 | oldWp = trkPnt;
|
---|
403 | }
|
---|
404 | }
|
---|
405 | Collections.sort(velocities);
|
---|
406 | if (velocities.isEmpty()) {
|
---|
407 | velocityScale.setRange(0, 120/3.6);
|
---|
408 | } else {
|
---|
409 | minval = velocities.get(velocities.size() / 20); // 5% percentile to remove outliers
|
---|
410 | maxval = velocities.get(velocities.size() * 19 / 20); // 95% percentile to remove outliers
|
---|
411 | velocityScale.setRange(minval, maxval);
|
---|
412 | }
|
---|
413 | } else if (colored == ColorMode.HDOP) {
|
---|
414 | for (Collection<WayPoint> segment : data.getLinesIterable(null)) {
|
---|
415 | for (WayPoint trkPnt : segment) {
|
---|
416 | Object val = trkPnt.get(GpxConstants.PT_HDOP);
|
---|
417 | if (val != null) {
|
---|
418 | double hdop = ((Float) val).doubleValue();
|
---|
419 | if (hdop > maxval) {
|
---|
420 | maxval = hdop;
|
---|
421 | }
|
---|
422 | if (hdop < minval) {
|
---|
423 | minval = hdop;
|
---|
424 | }
|
---|
425 | }
|
---|
426 | }
|
---|
427 | }
|
---|
428 | if (minval >= maxval) {
|
---|
429 | hdopScale.setRange(0, 100);
|
---|
430 | } else {
|
---|
431 | hdopScale.setRange(minval, maxval);
|
---|
432 | }
|
---|
433 | }
|
---|
434 | oldWp = null;
|
---|
435 | } else { // color mode not dynamic
|
---|
436 | velocityScale.setRange(0, colorTracksTune);
|
---|
437 | hdopScale.setRange(0, hdoprange);
|
---|
438 | }
|
---|
439 | double now = System.currentTimeMillis()/1000.0;
|
---|
440 | if (colored == ColorMode.TIME) {
|
---|
441 | Date[] bounds = data.getMinMaxTimeForAllTracks();
|
---|
442 | if (bounds.length >= 2) {
|
---|
443 | minval = bounds[0].getTime()/1000.0;
|
---|
444 | maxval = bounds[1].getTime()/1000.0;
|
---|
445 | } else {
|
---|
446 | minval = 0;
|
---|
447 | maxval = now;
|
---|
448 | }
|
---|
449 | dateScale.setRange(minval, maxval);
|
---|
450 | }
|
---|
451 |
|
---|
452 | // Now the colors for all the points will be assigned
|
---|
453 | for (Collection<WayPoint> segment : data.getLinesIterable(null)) {
|
---|
454 | if (!forceLines) { // don't draw lines between segments, unless forced to
|
---|
455 | oldWp = null;
|
---|
456 | }
|
---|
457 | for (WayPoint trkPnt : segment) {
|
---|
458 | LatLon c = trkPnt.getCoor();
|
---|
459 | trkPnt.customColoring = neutralColor;
|
---|
460 | if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
|
---|
461 | continue;
|
---|
462 | }
|
---|
463 | // now we are sure some color will be assigned
|
---|
464 | Color color = null;
|
---|
465 |
|
---|
466 | if (colored == ColorMode.HDOP) {
|
---|
467 | Float hdop = (Float) trkPnt.get(GpxConstants.PT_HDOP);
|
---|
468 | color = hdopScale.getColor(hdop);
|
---|
469 | }
|
---|
470 | if (oldWp != null) { // other coloring modes need segment for calcuation
|
---|
471 | double dist = c.greatCircleDistance(oldWp.getCoor());
|
---|
472 | boolean noDraw = false;
|
---|
473 | switch (colored) {
|
---|
474 | case VELOCITY:
|
---|
475 | double dtime = trkPnt.time - oldWp.time;
|
---|
476 | if (dtime > 0) {
|
---|
477 | color = velocityScale.getColor(dist / dtime);
|
---|
478 | } else {
|
---|
479 | color = velocityScale.getNoDataColor();
|
---|
480 | }
|
---|
481 | break;
|
---|
482 | case DIRECTION:
|
---|
483 | double dirColor = oldWp.getCoor().bearing(trkPnt.getCoor());
|
---|
484 | color = directionScale.getColor(dirColor);
|
---|
485 | break;
|
---|
486 | case TIME:
|
---|
487 | double t = trkPnt.time;
|
---|
488 | // skip bad timestamps and very short tracks
|
---|
489 | if (t > 0 && t <= now && maxval - minval > minTrackDurationForTimeColoring) {
|
---|
490 | color = dateScale.getColor(t);
|
---|
491 | } else {
|
---|
492 | color = dateScale.getNoDataColor();
|
---|
493 | }
|
---|
494 | break;
|
---|
495 | default: // Do nothing
|
---|
496 | }
|
---|
497 | if (!noDraw && (maxLineLength == -1 || dist <= maxLineLength)) {
|
---|
498 | trkPnt.drawLine = true;
|
---|
499 | double bearing = oldWp.getCoor().bearing(trkPnt.getCoor());
|
---|
500 | trkPnt.dir = ((int) (bearing / Math.PI * 4 + 1.5)) % 8;
|
---|
501 | } else {
|
---|
502 | trkPnt.drawLine = false;
|
---|
503 | }
|
---|
504 | } else { // make sure we reset outdated data
|
---|
505 | trkPnt.drawLine = false;
|
---|
506 | color = neutralColor;
|
---|
507 | }
|
---|
508 | if (color != null) {
|
---|
509 | trkPnt.customColoring = color;
|
---|
510 | }
|
---|
511 | oldWp = trkPnt;
|
---|
512 | }
|
---|
513 | }
|
---|
514 |
|
---|
515 | // heat mode
|
---|
516 | if (ColorMode.HEATMAP == colored && neutralColor != null) {
|
---|
517 |
|
---|
518 | // generate new user color map
|
---|
519 | heatMapLutUserColor = createColorLut(Color.BLACK, neutralColor.darker(),
|
---|
520 | neutralColor, neutralColor.brighter(), Color.WHITE);
|
---|
521 |
|
---|
522 | // decide what, keep order is sync with setting on GUI
|
---|
523 | Color[][] lut = {
|
---|
524 | heatMapLutUserColor,
|
---|
525 | heatMapLutColorJosmInferno,
|
---|
526 | heatMapLutColorJosmViridis,
|
---|
527 | heatMapLutColorJosmBrown2Green,
|
---|
528 | heatMapLutColorJosmRed2Blue
|
---|
529 | };
|
---|
530 |
|
---|
531 | // select by index
|
---|
532 | if (heatMapDrawColorTableIdx < lut.length) {
|
---|
533 | heatMapLutColor = lut[ heatMapDrawColorTableIdx ];
|
---|
534 | } else {
|
---|
535 | // fallback
|
---|
536 | heatMapLutColor = heatMapLutUserColor;
|
---|
537 | }
|
---|
538 |
|
---|
539 | // force redraw of image
|
---|
540 | heatMapCacheVisibleSegments = 0;
|
---|
541 | }
|
---|
542 |
|
---|
543 | computeCacheInSync = true;
|
---|
544 | }
|
---|
545 |
|
---|
546 | /**
|
---|
547 | * Draw all GPX ways segments
|
---|
548 | * @param g the common draw object to use
|
---|
549 | * @param mv the meta data to current displayed area
|
---|
550 | * @param visibleSegments segments visible in the current scope of mv
|
---|
551 | */
|
---|
552 | private void drawLines(Graphics2D g, MapView mv, List<WayPoint> visibleSegments) {
|
---|
553 | if (lines) {
|
---|
554 | Point old = null;
|
---|
555 | for (WayPoint trkPnt : visibleSegments) {
|
---|
556 | LatLon c = trkPnt.getCoor();
|
---|
557 | if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
|
---|
558 | continue;
|
---|
559 | }
|
---|
560 | Point screen = mv.getPoint(trkPnt.getEastNorth());
|
---|
561 | // skip points that are on the same screenposition
|
---|
562 | if (trkPnt.drawLine && old != null && ((old.x != screen.x) || (old.y != screen.y))) {
|
---|
563 | g.setColor(trkPnt.customColoring);
|
---|
564 | g.drawLine(old.x, old.y, screen.x, screen.y);
|
---|
565 | }
|
---|
566 | old = screen;
|
---|
567 | }
|
---|
568 | }
|
---|
569 | }
|
---|
570 |
|
---|
571 | /**
|
---|
572 | * Draw all GPX arrays
|
---|
573 | * @param g the common draw object to use
|
---|
574 | * @param mv the meta data to current displayed area
|
---|
575 | * @param visibleSegments segments visible in the current scope of mv
|
---|
576 | */
|
---|
577 | private void drawArrows(Graphics2D g, MapView mv, List<WayPoint> visibleSegments) {
|
---|
578 | /****************************************************************
|
---|
579 | ********** STEP 3b - DRAW NICE ARROWS **************************
|
---|
580 | ****************************************************************/
|
---|
581 | if (lines && direction && !alternateDirection) {
|
---|
582 | Point old = null;
|
---|
583 | Point oldA = null; // last arrow painted
|
---|
584 | for (WayPoint trkPnt : visibleSegments) {
|
---|
585 | LatLon c = trkPnt.getCoor();
|
---|
586 | if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
|
---|
587 | continue;
|
---|
588 | }
|
---|
589 | if (trkPnt.drawLine) {
|
---|
590 | Point screen = mv.getPoint(trkPnt.getEastNorth());
|
---|
591 | // skip points that are on the same screenposition
|
---|
592 | if (old != null
|
---|
593 | && (oldA == null || screen.x < oldA.x - delta || screen.x > oldA.x + delta
|
---|
594 | || screen.y < oldA.y - delta || screen.y > oldA.y + delta)) {
|
---|
595 | g.setColor(trkPnt.customColoring);
|
---|
596 | double t = Math.atan2((double) screen.y - old.y, (double) screen.x - old.x) + Math.PI;
|
---|
597 | g.drawLine(screen.x, screen.y, (int) (screen.x + 10 * Math.cos(t - PHI)),
|
---|
598 | (int) (screen.y + 10 * Math.sin(t - PHI)));
|
---|
599 | g.drawLine(screen.x, screen.y, (int) (screen.x + 10 * Math.cos(t + PHI)),
|
---|
600 | (int) (screen.y + 10 * Math.sin(t + PHI)));
|
---|
601 | oldA = screen;
|
---|
602 | }
|
---|
603 | old = screen;
|
---|
604 | }
|
---|
605 | } // end for trkpnt
|
---|
606 | }
|
---|
607 |
|
---|
608 | /****************************************************************
|
---|
609 | ********** STEP 3c - DRAW FAST ARROWS **************************
|
---|
610 | ****************************************************************/
|
---|
611 | if (lines && direction && alternateDirection) {
|
---|
612 | Point old = null;
|
---|
613 | Point oldA = null; // last arrow painted
|
---|
614 | for (WayPoint trkPnt : visibleSegments) {
|
---|
615 | LatLon c = trkPnt.getCoor();
|
---|
616 | if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
|
---|
617 | continue;
|
---|
618 | }
|
---|
619 | if (trkPnt.drawLine) {
|
---|
620 | Point screen = mv.getPoint(trkPnt.getEastNorth());
|
---|
621 | // skip points that are on the same screenposition
|
---|
622 | if (old != null
|
---|
623 | && (oldA == null || screen.x < oldA.x - delta || screen.x > oldA.x + delta
|
---|
624 | || screen.y < oldA.y - delta || screen.y > oldA.y + delta)) {
|
---|
625 | g.setColor(trkPnt.customColoring);
|
---|
626 | g.drawLine(screen.x, screen.y, screen.x + dir[trkPnt.dir][0], screen.y
|
---|
627 | + dir[trkPnt.dir][1]);
|
---|
628 | g.drawLine(screen.x, screen.y, screen.x + dir[trkPnt.dir][2], screen.y
|
---|
629 | + dir[trkPnt.dir][3]);
|
---|
630 | oldA = screen;
|
---|
631 | }
|
---|
632 | old = screen;
|
---|
633 | }
|
---|
634 | } // end for trkpnt
|
---|
635 | }
|
---|
636 | }
|
---|
637 |
|
---|
638 | /**
|
---|
639 | * Draw all GPX points
|
---|
640 | * @param g the common draw object to use
|
---|
641 | * @param mv the meta data to current displayed area
|
---|
642 | * @param visibleSegments segments visible in the current scope of mv
|
---|
643 | */
|
---|
644 | private void drawPoints(Graphics2D g, MapView mv, List<WayPoint> visibleSegments) {
|
---|
645 | /****************************************************************
|
---|
646 | ********** STEP 3d - DRAW LARGE POINTS AND HDOP CIRCLE *********
|
---|
647 | ****************************************************************/
|
---|
648 | if (large || hdopCircle) {
|
---|
649 | final int halfSize = largesize/2;
|
---|
650 | for (WayPoint trkPnt : visibleSegments) {
|
---|
651 | LatLon c = trkPnt.getCoor();
|
---|
652 | if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
|
---|
653 | continue;
|
---|
654 | }
|
---|
655 | Point screen = mv.getPoint(trkPnt.getEastNorth());
|
---|
656 |
|
---|
657 |
|
---|
658 | if (hdopCircle && trkPnt.get(GpxConstants.PT_HDOP) != null) {
|
---|
659 | // hdop value
|
---|
660 | float hdop = (Float) trkPnt.get(GpxConstants.PT_HDOP);
|
---|
661 | if (hdop < 0) {
|
---|
662 | hdop = 0;
|
---|
663 | }
|
---|
664 | Color customColoringTransparent = hdopAlpha < 0 ? trkPnt.customColoring :
|
---|
665 | new Color((trkPnt.customColoring.getRGB() & 0x00ffffff) | (hdopAlpha << 24), true);
|
---|
666 | g.setColor(customColoringTransparent);
|
---|
667 | // hdop circles
|
---|
668 | int hdopp = mv.getPoint(new LatLon(
|
---|
669 | trkPnt.getCoor().lat(),
|
---|
670 | trkPnt.getCoor().lon() + 2d*6*hdop*360/40000000d)).x - screen.x;
|
---|
671 | g.drawArc(screen.x-hdopp/2, screen.y-hdopp/2, hdopp, hdopp, 0, 360);
|
---|
672 | }
|
---|
673 | if (large) {
|
---|
674 | // color the large GPS points like the gps lines
|
---|
675 | if (trkPnt.customColoring != null) {
|
---|
676 | Color customColoringTransparent = largePointAlpha < 0 ? trkPnt.customColoring :
|
---|
677 | new Color((trkPnt.customColoring.getRGB() & 0x00ffffff) | (largePointAlpha << 24), true);
|
---|
678 |
|
---|
679 | g.setColor(customColoringTransparent);
|
---|
680 | }
|
---|
681 | g.fillRect(screen.x-halfSize, screen.y-halfSize, largesize, largesize);
|
---|
682 | }
|
---|
683 | } // end for trkpnt
|
---|
684 | } // end if large || hdopcircle
|
---|
685 |
|
---|
686 | /****************************************************************
|
---|
687 | ********** STEP 3e - DRAW SMALL POINTS FOR LINES ***************
|
---|
688 | ****************************************************************/
|
---|
689 | if (!large && lines) {
|
---|
690 | g.setColor(neutralColor);
|
---|
691 | for (WayPoint trkPnt : visibleSegments) {
|
---|
692 | LatLon c = trkPnt.getCoor();
|
---|
693 | if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
|
---|
694 | continue;
|
---|
695 | }
|
---|
696 | if (!trkPnt.drawLine) {
|
---|
697 | Point screen = mv.getPoint(trkPnt.getEastNorth());
|
---|
698 | g.drawRect(screen.x, screen.y, 0, 0);
|
---|
699 | }
|
---|
700 | } // end for trkpnt
|
---|
701 | } // end if large
|
---|
702 |
|
---|
703 | /****************************************************************
|
---|
704 | ********** STEP 3f - DRAW SMALL POINTS INSTEAD OF LINES ********
|
---|
705 | ****************************************************************/
|
---|
706 | if (!large && !lines) {
|
---|
707 | g.setColor(neutralColor);
|
---|
708 | for (WayPoint trkPnt : visibleSegments) {
|
---|
709 | LatLon c = trkPnt.getCoor();
|
---|
710 | if (Double.isNaN(c.lat()) || Double.isNaN(c.lon())) {
|
---|
711 | continue;
|
---|
712 | }
|
---|
713 | Point screen = mv.getPoint(trkPnt.getEastNorth());
|
---|
714 | g.setColor(trkPnt.customColoring);
|
---|
715 | g.drawRect(screen.x, screen.y, 0, 0);
|
---|
716 | } // end for trkpnt
|
---|
717 | } // end if large
|
---|
718 | }
|
---|
719 |
|
---|
720 | /**
|
---|
721 | * Draw GPX lines by using alpha blending
|
---|
722 | * @param g the common draw object to use
|
---|
723 | * @param mv the meta data to current displayed area
|
---|
724 | * @param visibleSegments segments visible in the current scope of mv
|
---|
725 | * @param layerAlpha the color alpha value set for that operation
|
---|
726 | */
|
---|
727 | private void drawLinesAlpha(Graphics2D g, MapView mv, List<WayPoint> visibleSegments, float layerAlpha) {
|
---|
728 |
|
---|
729 | // 1st. backup the paint environment ----------------------------------
|
---|
730 | Composite oldComposite = g.getComposite();
|
---|
731 | Stroke oldStroke = g.getStroke();
|
---|
732 | Paint oldPaint = g.getPaint();
|
---|
733 |
|
---|
734 | // 2nd. determine current scale factors -------------------------------
|
---|
735 |
|
---|
736 | // adjust global settings
|
---|
737 | final int globalLineWidth = Math.min(Math.max(lineWidth, 1), 20);
|
---|
738 |
|
---|
739 | // cache scale of view
|
---|
740 | final double zoomScale = mv.getScale();
|
---|
741 |
|
---|
742 | // 3rd. determine current paint parameters -----------------------------
|
---|
743 |
|
---|
744 | // alpha value is based on zoom and line with combined with global layer alpha
|
---|
745 | float theLineAlpha = Math.min(Math.max((0.50f/(float) zoomScale)/(globalLineWidth + 1), 0.01f), 0.50f) * layerAlpha;
|
---|
746 | final int theLineWith = (int) (lineWidth / zoomScale) + 1;
|
---|
747 |
|
---|
748 | // 4th setup virtual paint area ----------------------------------------
|
---|
749 |
|
---|
750 | // set line format and alpha channel for all overlays (more lines -> few overlap -> more transparency)
|
---|
751 | g.setStroke(new BasicStroke(theLineWith, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
|
---|
752 | g.setComposite(AlphaComposite.SrcOver.derive(theLineAlpha));
|
---|
753 |
|
---|
754 | // last used / calculated entries
|
---|
755 | Point lastPaintPnt = null;
|
---|
756 |
|
---|
757 | // 5th draw the layer ---------------------------------------------------
|
---|
758 |
|
---|
759 | // for all points
|
---|
760 | for (WayPoint trkPnt : visibleSegments) {
|
---|
761 |
|
---|
762 | // transform coordinates
|
---|
763 | final Point paintPnt = mv.getPoint(trkPnt.getEastNorth());
|
---|
764 |
|
---|
765 | // skip single points
|
---|
766 | if (lastPaintPnt != null && trkPnt.drawLine && !lastPaintPnt.equals(paintPnt)) {
|
---|
767 |
|
---|
768 | // set different color
|
---|
769 | g.setColor(trkPnt.customColoring);
|
---|
770 |
|
---|
771 | // draw it
|
---|
772 | g.drawLine(lastPaintPnt.x, lastPaintPnt.y, paintPnt.x, paintPnt.y);
|
---|
773 | }
|
---|
774 |
|
---|
775 | lastPaintPnt = paintPnt;
|
---|
776 | }
|
---|
777 |
|
---|
778 | // @last restore modified paint environment -----------------------------
|
---|
779 | g.setPaint(oldPaint);
|
---|
780 | g.setStroke(oldStroke);
|
---|
781 | g.setComposite(oldComposite);
|
---|
782 | }
|
---|
783 |
|
---|
784 | /**
|
---|
785 | * Creates a linear distributed colormap by linear blending between colors
|
---|
786 | * @param colors 1..n colors
|
---|
787 | * @return array of Color objects
|
---|
788 | */
|
---|
789 | protected static Color[] createColorLut(Color... colors) {
|
---|
790 |
|
---|
791 | // number of lookup entries
|
---|
792 | int tableSize = 256;
|
---|
793 |
|
---|
794 | // create image an paint object
|
---|
795 | BufferedImage img = new BufferedImage(tableSize, 1, BufferedImage.TYPE_INT_RGB);
|
---|
796 | Graphics2D g = img.createGraphics();
|
---|
797 |
|
---|
798 | float[] fract = new float[ colors.length ];
|
---|
799 |
|
---|
800 | // distribute fractions (define position of color in map)
|
---|
801 | for (int i = 0; i < colors.length; ++i) {
|
---|
802 | fract[i] = i * (1.0f / colors.length);
|
---|
803 | }
|
---|
804 |
|
---|
805 | // draw the gradient map
|
---|
806 | LinearGradientPaint gradient = new LinearGradientPaint(0, 0, tableSize, 1, fract, colors,
|
---|
807 | MultipleGradientPaint.CycleMethod.NO_CYCLE);
|
---|
808 | g.setPaint(gradient);
|
---|
809 | g.fillRect(0, 0, tableSize, 1);
|
---|
810 | g.dispose();
|
---|
811 |
|
---|
812 | // access it via raw interface
|
---|
813 | final Raster imgRaster = img.getData();
|
---|
814 |
|
---|
815 | // the pixel storage
|
---|
816 | int[] pixel = new int[1];
|
---|
817 |
|
---|
818 | Color[] colorTable = new Color[tableSize];
|
---|
819 |
|
---|
820 | // map the range 0..255 to 0..pi/2
|
---|
821 | final double mapTo90Deg = Math.PI / 2.0 / 255.0;
|
---|
822 |
|
---|
823 | // create the lookup table
|
---|
824 | for (int i = 0; i < tableSize; i++) {
|
---|
825 |
|
---|
826 | // get next single pixel
|
---|
827 | imgRaster.getDataElements((int) (i * (double) img.getWidth() / tableSize), 0, pixel);
|
---|
828 |
|
---|
829 | // get color and map
|
---|
830 | Color c = new Color(pixel[0]);
|
---|
831 |
|
---|
832 | // smooth alpha like sin curve
|
---|
833 | int alpha = (int) (Math.sin(i * mapTo90Deg) * 255);
|
---|
834 |
|
---|
835 | // alpha with pre-offset, first color -> full transparent
|
---|
836 | alpha = i > 0 ? (10 + alpha) : 0;
|
---|
837 |
|
---|
838 | // shrink to maximum bound
|
---|
839 | if (alpha > 255) {
|
---|
840 | alpha = 255;
|
---|
841 | }
|
---|
842 |
|
---|
843 | // increase transparency for higher values ( avoid big saturation )
|
---|
844 | if (i > 240 && 255 == alpha) {
|
---|
845 | alpha -= (i - 240);
|
---|
846 | }
|
---|
847 |
|
---|
848 | // fill entry in table, assign a alpha value
|
---|
849 | colorTable[i] = new Color(c.getRed(), c.getGreen(), c.getBlue(), alpha);
|
---|
850 | }
|
---|
851 |
|
---|
852 | // transform into lookup table
|
---|
853 | return colorTable;
|
---|
854 | }
|
---|
855 |
|
---|
856 | /**
|
---|
857 | * Creates a darker color
|
---|
858 | * @param in Color object
|
---|
859 | * @param adjust darker adjustment amount
|
---|
860 | * @return new Color
|
---|
861 | */
|
---|
862 | protected static Color darkerColor(Color in, float adjust) {
|
---|
863 |
|
---|
864 | final float r = (float) in.getRed()/255;
|
---|
865 | final float g = (float) in.getGreen()/255;
|
---|
866 | final float b = (float) in.getBlue()/255;
|
---|
867 |
|
---|
868 | return new Color(r*adjust, g*adjust, b*adjust);
|
---|
869 | }
|
---|
870 |
|
---|
871 | /**
|
---|
872 | * Creates a colormap by using a static color map with 1..n colors (RGB 0.0 ..1.0)
|
---|
873 | * @param str the filename (without extension) to look for into data/gpx
|
---|
874 | * @return the parsed colormap
|
---|
875 | */
|
---|
876 | protected static Color[] createColorFromResource(String str) {
|
---|
877 |
|
---|
878 | // create resource string
|
---|
879 | final String colorFile = "resource://data/gpx/" + str + ".txt";
|
---|
880 |
|
---|
881 | List<Color> colorList = new ArrayList<>();
|
---|
882 |
|
---|
883 | // try to load the file
|
---|
884 | try (CachedFile cf = new CachedFile(colorFile); BufferedReader br = cf.getContentReader()) {
|
---|
885 |
|
---|
886 | String line;
|
---|
887 |
|
---|
888 | // process lines
|
---|
889 | while ((line = br.readLine()) != null) {
|
---|
890 |
|
---|
891 | // use comma as separator
|
---|
892 | String[] column = line.split(",");
|
---|
893 |
|
---|
894 | // empty or comment line
|
---|
895 | if (column.length < 3 || column[0].startsWith("#")) {
|
---|
896 | continue;
|
---|
897 | }
|
---|
898 |
|
---|
899 | // extract RGB value
|
---|
900 | float r = Float.parseFloat(column[0]);
|
---|
901 | float g = Float.parseFloat(column[1]);
|
---|
902 | float b = Float.parseFloat(column[2]);
|
---|
903 |
|
---|
904 | // some color tables are 0..1.0 and some 0.255
|
---|
905 | float scale = (r < 1 && g < 1 && b < 1) ? 1 : 255;
|
---|
906 |
|
---|
907 | colorList.add(new Color(r/scale, g/scale, b/scale));
|
---|
908 | }
|
---|
909 | } catch (IOException e) {
|
---|
910 | throw new JosmRuntimeException(e);
|
---|
911 | }
|
---|
912 |
|
---|
913 | // fallback if empty or failed
|
---|
914 | if (colorList.isEmpty()) {
|
---|
915 | colorList.add(Color.BLACK);
|
---|
916 | colorList.add(Color.WHITE);
|
---|
917 | } else {
|
---|
918 | // add additional darker elements to end of list
|
---|
919 | final Color lastColor = colorList.get(colorList.size() - 1);
|
---|
920 | colorList.add(darkerColor(lastColor, 0.975f));
|
---|
921 | colorList.add(darkerColor(lastColor, 0.950f));
|
---|
922 | }
|
---|
923 |
|
---|
924 | return createColorLut(colorList.toArray(new Color[ colorList.size() ]));
|
---|
925 | }
|
---|
926 |
|
---|
927 | /**
|
---|
928 | * Draw gray heat map with current Graphics2D setting
|
---|
929 | * @param gB the common draw object to use
|
---|
930 | * @param mv the meta data to current displayed area
|
---|
931 | * @param listSegm segments visible in the current scope of mv
|
---|
932 | * @param foreComp composite use to draw foreground objects
|
---|
933 | * @param foreStroke stroke use to draw foreground objects
|
---|
934 | * @param backComp composite use to draw background objects
|
---|
935 | * @param backStroke stroke use to draw background objects
|
---|
936 | */
|
---|
937 | private void drawHeatGrayMap(Graphics2D gB, MapView mv, List<WayPoint> listSegm,
|
---|
938 | Composite foreComp, Stroke foreStroke,
|
---|
939 | Composite backComp, Stroke backStroke) {
|
---|
940 |
|
---|
941 | // draw foreground
|
---|
942 | boolean drawForeground = foreComp != null && foreStroke != null;
|
---|
943 |
|
---|
944 | // set initial values
|
---|
945 | gB.setStroke(backStroke); gB.setComposite(backComp);
|
---|
946 |
|
---|
947 | // get last point in list
|
---|
948 | final WayPoint lastPnt = !listSegm.isEmpty() ? listSegm.get(listSegm.size() - 1) : null;
|
---|
949 |
|
---|
950 | // for all points, draw single lines by using optimized drawing
|
---|
951 | for (WayPoint trkPnt : listSegm) {
|
---|
952 |
|
---|
953 | // get transformed coordinates
|
---|
954 | final Point paintPnt = mv.getPoint(trkPnt.getEastNorth());
|
---|
955 |
|
---|
956 | // end of line segment or end of list reached
|
---|
957 | if (!trkPnt.drawLine || (lastPnt == trkPnt)) {
|
---|
958 |
|
---|
959 | // convert to primitive type
|
---|
960 | final int[] polyXArr = heatMapPolyX.stream().mapToInt(Integer::intValue).toArray();
|
---|
961 | final int[] polyYArr = heatMapPolyY.stream().mapToInt(Integer::intValue).toArray();
|
---|
962 |
|
---|
963 | // a.) draw background
|
---|
964 | gB.drawPolyline(polyXArr, polyYArr, polyXArr.length);
|
---|
965 |
|
---|
966 | // b.) draw extra foreground
|
---|
967 | if (drawForeground && heatMapDrawExtraLine) {
|
---|
968 |
|
---|
969 | gB.setStroke(foreStroke); gB.setComposite(foreComp);
|
---|
970 | gB.drawPolyline(polyXArr, polyYArr, polyXArr.length);
|
---|
971 | gB.setStroke(backStroke); gB.setComposite(backComp);
|
---|
972 | }
|
---|
973 |
|
---|
974 | // drop used points
|
---|
975 | heatMapPolyX.clear(); heatMapPolyY.clear();
|
---|
976 | }
|
---|
977 |
|
---|
978 | // store only the integer part (make sense because pixel is 1:1 here)
|
---|
979 | heatMapPolyX.add((int) paintPnt.getX());
|
---|
980 | heatMapPolyY.add((int) paintPnt.getY());
|
---|
981 | }
|
---|
982 | }
|
---|
983 |
|
---|
984 | /**
|
---|
985 | * Map the gray map to heat map and draw them with current Graphics2D setting
|
---|
986 | * @param g the common draw object to use
|
---|
987 | * @param imgGray gray scale input image
|
---|
988 | * @param sampleRaster the line with for drawing
|
---|
989 | * @param outlineWidth line width for outlines
|
---|
990 | */
|
---|
991 | private void drawHeatMapGrayMap(Graphics2D g, BufferedImage imgGray, int sampleRaster, int outlineWidth) {
|
---|
992 |
|
---|
993 | final int[] imgPixels = ((DataBufferInt) imgGray.getRaster().getDataBuffer()).getData();
|
---|
994 |
|
---|
995 | // samples offset and bounds are scaled with line width derived from zoom level
|
---|
996 | final int offX = Math.max(1, sampleRaster);
|
---|
997 | final int offY = Math.max(1, sampleRaster);
|
---|
998 |
|
---|
999 | final int maxPixelX = imgGray.getWidth();
|
---|
1000 | final int maxPixelY = imgGray.getHeight();
|
---|
1001 |
|
---|
1002 | // always full or outlines at big samples rasters
|
---|
1003 | final boolean drawOutlines = (outlineWidth > 0) && ((0 == sampleRaster) || (sampleRaster > 8));
|
---|
1004 |
|
---|
1005 | // backup stroke
|
---|
1006 | final Stroke oldStroke = g.getStroke();
|
---|
1007 |
|
---|
1008 | // use basic stroke for outlines and default transparency
|
---|
1009 | g.setStroke(new BasicStroke(outlineWidth));
|
---|
1010 |
|
---|
1011 | int lastPixelY = 0;
|
---|
1012 | int lastPixelColor = 0;
|
---|
1013 |
|
---|
1014 | // resample gray scale image with line linear weight of next sample in line
|
---|
1015 | // process each line and draw pixels / rectangles with same color with one operations
|
---|
1016 | for (int x = 0; x < maxPixelX; x += offX) {
|
---|
1017 | for (int y = 0; y < maxPixelY; y += offY) {
|
---|
1018 |
|
---|
1019 | int thePixelColor = 0;
|
---|
1020 |
|
---|
1021 | // sample the image (it is gray scale)
|
---|
1022 | int offset = (x * maxPixelX) + y;
|
---|
1023 |
|
---|
1024 | // merge next pixels of window of line
|
---|
1025 | for (int k = 0; k < offX && offset + k < imgPixels.length; k++) {
|
---|
1026 | thePixelColor += imgPixels[offset+k] & 0xFF;
|
---|
1027 | }
|
---|
1028 |
|
---|
1029 | // mean value
|
---|
1030 | thePixelColor /= offX;
|
---|
1031 |
|
---|
1032 | // restart -> use initial sample
|
---|
1033 | if (0 == y) {
|
---|
1034 | lastPixelY = 0; lastPixelColor = thePixelColor - 1;
|
---|
1035 | }
|
---|
1036 |
|
---|
1037 | boolean bDrawIt = false;
|
---|
1038 |
|
---|
1039 | // when one of segment is mapped to black
|
---|
1040 | bDrawIt = bDrawIt || (lastPixelColor == 0) || (thePixelColor == 0);
|
---|
1041 |
|
---|
1042 | // different color
|
---|
1043 | bDrawIt = bDrawIt || (Math.abs(lastPixelColor-thePixelColor) > 0);
|
---|
1044 |
|
---|
1045 | // when line is finished draw always
|
---|
1046 | bDrawIt = bDrawIt || (y >= (maxPixelY-offY));
|
---|
1047 |
|
---|
1048 | if (bDrawIt) {
|
---|
1049 |
|
---|
1050 | // draw only foreground pixels
|
---|
1051 | if (lastPixelColor > 0) {
|
---|
1052 |
|
---|
1053 | // gray to RGB mapping
|
---|
1054 | g.setColor(heatMapLutColor[ lastPixelColor ]);
|
---|
1055 |
|
---|
1056 | // box from from last Y pixel to current pixel
|
---|
1057 | if (drawOutlines) {
|
---|
1058 | g.drawRect(lastPixelY, x, offY + y - lastPixelY, offX);
|
---|
1059 | } else {
|
---|
1060 | g.fillRect(lastPixelY, x, offY + y - lastPixelY, offX);
|
---|
1061 | }
|
---|
1062 | }
|
---|
1063 |
|
---|
1064 | // restart detection
|
---|
1065 | lastPixelY = y; lastPixelColor = thePixelColor;
|
---|
1066 | }
|
---|
1067 | }
|
---|
1068 | }
|
---|
1069 |
|
---|
1070 | // recover
|
---|
1071 | g.setStroke(oldStroke);
|
---|
1072 | }
|
---|
1073 |
|
---|
1074 | /**
|
---|
1075 | * Collect and draw GPS segments and displays a heat-map
|
---|
1076 | * @param g the common draw object to use
|
---|
1077 | * @param mv the meta data to current displayed area
|
---|
1078 | * @param visibleSegments segments visible in the current scope of mv
|
---|
1079 | */
|
---|
1080 | private void drawHeatMap(Graphics2D g, MapView mv, List<WayPoint> visibleSegments) {
|
---|
1081 |
|
---|
1082 | // get bounds of screen image and projection, zoom and adjust input parameters
|
---|
1083 | final Rectangle screenBounds = g.getDeviceConfiguration().getBounds();
|
---|
1084 | final double zoomScale = mv.getScale();
|
---|
1085 |
|
---|
1086 | // adjust global settings ( zero = default line width )
|
---|
1087 | final int globalLineWidth = (0 == lineWidth) ? 1 : Math.min(Math.max(lineWidth, 1), 20);
|
---|
1088 |
|
---|
1089 | // 1st setup virtual paint area ----------------------------------------
|
---|
1090 |
|
---|
1091 | // HACK: sometime screen bounds does not return valid values when picture is shifted
|
---|
1092 | // therefore we use a bigger area to avoid missing parts of image
|
---|
1093 | screenBounds.width = screenBounds.width * 3 / 2;
|
---|
1094 | screenBounds.height = screenBounds.height * 3 / 2;
|
---|
1095 |
|
---|
1096 | // new image buffer needed
|
---|
1097 | final boolean imageSetup = null == heatMapImgGray || !heatMapCacheScreenBounds.equals(screenBounds);
|
---|
1098 |
|
---|
1099 | // screen bounds changed, need new image buffer ?
|
---|
1100 | if (imageSetup) {
|
---|
1101 | // we would use a "pure" grayscale image, but there is not efficient way to map gray scale values to RGB)
|
---|
1102 | heatMapImgGray = new BufferedImage(screenBounds.width, screenBounds.height, BufferedImage.TYPE_INT_ARGB);
|
---|
1103 | heatMapGraph2d = heatMapImgGray.createGraphics();
|
---|
1104 | heatMapGraph2d.setBackground(new Color(0, 0, 0, 255));
|
---|
1105 | heatMapGraph2d.setColor(Color.WHITE);
|
---|
1106 |
|
---|
1107 | // cache it
|
---|
1108 | heatMapCacheScreenBounds = screenBounds;
|
---|
1109 | }
|
---|
1110 |
|
---|
1111 | // 2nd. determine current scale factors -------------------------------
|
---|
1112 |
|
---|
1113 | // the line width (foreground: draw extra small footprint line of track)
|
---|
1114 | final int lineWidthB = (int) Math.max(1.5f * (globalLineWidth / zoomScale) + 1, 2);
|
---|
1115 | final int lineWidthF = lineWidthB > 2 ? (globalLineWidth - 1) : 0;
|
---|
1116 |
|
---|
1117 | // recalculation of image needed
|
---|
1118 | final boolean imageRecalc = heatMapCacheVisibleSegments != visibleSegments.size() ||
|
---|
1119 | heatMapCacheZoomScale != zoomScale ||
|
---|
1120 | heatMapCacheLineWith != globalLineWidth;
|
---|
1121 |
|
---|
1122 | // 3rd Calculate the heat map data by draw GPX traces with alpha value ----------
|
---|
1123 |
|
---|
1124 | // need re-generation of gray image ?
|
---|
1125 | if (imageSetup || imageRecalc) {
|
---|
1126 |
|
---|
1127 | // clear background
|
---|
1128 | heatMapGraph2d.clearRect(0, 0, heatMapImgGray.getWidth(), heatMapImgGray.getHeight());
|
---|
1129 |
|
---|
1130 | // alpha combines both values, therefore the foreground shall be lighter
|
---|
1131 | final float lineAlphaB = Math.min(Math.max((0.40f/(float) zoomScale)/(globalLineWidth + 1), 0.01f), 0.40f);
|
---|
1132 | final float lineAlphaF = lineAlphaB / 1.5f;
|
---|
1133 |
|
---|
1134 | // derive draw parameters and draw
|
---|
1135 | drawHeatGrayMap(heatMapGraph2d, mv, visibleSegments,
|
---|
1136 | lineWidthF > 1 ? AlphaComposite.SrcOver.derive(lineAlphaF) : null,
|
---|
1137 | new BasicStroke(lineWidthF, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND),
|
---|
1138 | AlphaComposite.SrcOver.derive(lineAlphaB),
|
---|
1139 | new BasicStroke(lineWidthB, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
|
---|
1140 |
|
---|
1141 | // remember draw parameters
|
---|
1142 | heatMapCacheVisibleSegments = visibleSegments.size();
|
---|
1143 | heatMapCacheZoomScale = zoomScale;
|
---|
1144 | heatMapCacheLineWith = lineWidth;
|
---|
1145 | }
|
---|
1146 |
|
---|
1147 | // 4th. Draw data on target layer, map data via color lookup table --------------
|
---|
1148 | drawHeatMapGrayMap(g, heatMapImgGray,
|
---|
1149 | lineWidthB > 2 ? (lineWidthB / 2) : 1,
|
---|
1150 | lineWidth > 2 ? (lineWidth - 2) : 1);
|
---|
1151 | }
|
---|
1152 |
|
---|
1153 | /**
|
---|
1154 | * Apply default color configuration to way segments
|
---|
1155 | * @param visibleSegments segments visible in the current scope of mv
|
---|
1156 | */
|
---|
1157 | private void fixColors(List<WayPoint> visibleSegments) {
|
---|
1158 | for (WayPoint trkPnt : visibleSegments) {
|
---|
1159 | if (trkPnt.customColoring == null) {
|
---|
1160 | trkPnt.customColoring = neutralColor;
|
---|
1161 | }
|
---|
1162 | }
|
---|
1163 | }
|
---|
1164 |
|
---|
1165 | /**
|
---|
1166 | * Check cache validity set necessary flags
|
---|
1167 | */
|
---|
1168 | private void checkCache() {
|
---|
1169 | if ((computeCacheMaxLineLengthUsed != maxLineLength)
|
---|
1170 | || (computeCacheColored != colored)
|
---|
1171 | || (computeCacheColorTracksTune != colorTracksTune)
|
---|
1172 | || (computeCacheColorDynamic != colorModeDynamic)
|
---|
1173 | || (computeCacheHeatMapDrawColorTableIdx != heatMapDrawColorTableIdx)
|
---|
1174 | || (!neutralColor.equals(computeCacheColorUsed))
|
---|
1175 | ) {
|
---|
1176 | computeCacheMaxLineLengthUsed = maxLineLength;
|
---|
1177 | computeCacheInSync = false;
|
---|
1178 | computeCacheColorUsed = neutralColor;
|
---|
1179 | computeCacheColored = colored;
|
---|
1180 | computeCacheColorTracksTune = colorTracksTune;
|
---|
1181 | computeCacheColorDynamic = colorModeDynamic;
|
---|
1182 | computeCacheHeatMapDrawColorTableIdx = heatMapDrawColorTableIdx;
|
---|
1183 | }
|
---|
1184 | }
|
---|
1185 |
|
---|
1186 | /**
|
---|
1187 | * callback when data is changed, invalidate cached configuration parameters
|
---|
1188 | */
|
---|
1189 | public void dataChanged() {
|
---|
1190 | computeCacheInSync = false;
|
---|
1191 | }
|
---|
1192 |
|
---|
1193 | /**
|
---|
1194 | * Draw all GPX arrays
|
---|
1195 | * @param g the common draw object to use
|
---|
1196 | * @param mv the meta data to current displayed area
|
---|
1197 | */
|
---|
1198 | public void drawColorBar(Graphics2D g, MapView mv) {
|
---|
1199 | int w = mv.getWidth();
|
---|
1200 |
|
---|
1201 | // set do default
|
---|
1202 | g.setComposite(AlphaComposite.SrcOver.derive(1.00f));
|
---|
1203 |
|
---|
1204 | if (colored == ColorMode.HDOP) {
|
---|
1205 | hdopScale.drawColorBar(g, w-30, 50, 20, 100, 1.0);
|
---|
1206 | } else if (colored == ColorMode.VELOCITY) {
|
---|
1207 | SystemOfMeasurement som = SystemOfMeasurement.getSystemOfMeasurement();
|
---|
1208 | velocityScale.drawColorBar(g, w-30, 50, 20, 100, som.speedValue);
|
---|
1209 | } else if (colored == ColorMode.DIRECTION) {
|
---|
1210 | directionScale.drawColorBar(g, w-30, 50, 20, 100, 180.0/Math.PI);
|
---|
1211 | }
|
---|
1212 | }
|
---|
1213 | }
|
---|