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