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