gov/nasa/worldwind/layers/TiledImageLayer.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7 package gov.nasa.worldwind.layers;
   8
   9 import com.sun.opengl.util.j2d.TextRenderer;
  10 import gov.nasa.worldwind.WorldWind;
  11 import gov.nasa.worldwind.geom.*;
  12 import gov.nasa.worldwind.render.DrawContext;
  13 import gov.nasa.worldwind.retrieve.*;
  14 import gov.nasa.worldwind.util.*;
  15 import gov.nasa.worldwind.View;
  16
  17 import javax.imageio.ImageIO;
  18 import javax.media.opengl.GL;
  19 import java.awt.*;
  20 import java.awt.image.*;
  21 import java.io.*;
  22 import java.net.*;
  23 import java.nio.ByteBuffer;
  24 import java.util.*;
  25 import java.util.concurrent.PriorityBlockingQueue;
  26
  27 /**
  28  * @author tag
  29  * @version $Id: TiledImageLayer.java 3685 2007-12-03 19:51:05Z tgaskins $
  30  */
  31 public abstract class TiledImageLayer extends AbstractLayer
  32 {
  33     // Infrastructure
  34     private static final LevelComparer levelComparer = new LevelComparer();
  35     private final LevelSet levels;
  36     private ArrayList<TextureTile> topLevels;
  37     private boolean forceLevelZeroLoads = false;
  38     private boolean levelZeroLoaded = false;
  39     private boolean retainLevelZeroTiles = false;
  40     private String tileCountName;
  41     private double splitScale = 0.9; // TODO: Make configurable
  42
  43     // Diagnostic flags
  44     private boolean showImageTileOutlines = false;
  45     private boolean drawTileBoundaries = false;
  46     private boolean useTransparentTextures = false;
  47     private boolean drawTileIDs = false;
  48     private boolean drawBoundingVolumes = false;
  49     private TextRenderer textRenderer = null;
  50
  51     // Stuff computed each frame
  52     private ArrayList<TextureTile> currentTiles = new ArrayList<TextureTile>();
  53     private TextureTile currentResourceTile;
  54     private Vec4 referencePoint;
  55     private boolean atMaxResolution = false;
  56     private PriorityBlockingQueue<Runnable> requestQ = new PriorityBlockingQueue<Runnable>(200);
  57
  58     abstract protected void requestTexture(DrawContext dc, TextureTile tile);
  59
  60     abstract protected void forceTextureLoad(TextureTile tile);
  61
  62     public TiledImageLayer(LevelSet levelSet)
  63     {
  64         if (levelSet == null)
  65         {
  66             String message = Logging.getMessage("nullValue.LevelSetIsNull");
  67             Logging.logger().severe(message);
  68             throw new IllegalArgumentException(message);
  69         }
  70
  71         this.levels = new LevelSet(levelSet); // the caller's levelSet may change internally, so we copy it.
  72
  73         this.createTopLevelTiles();
  74
  75         this.setPickEnabled(false); // textures are assumed to be terrain unless specifically indicated otherwise.
  76         this.tileCountName = this.getName() + " Tiles";
  77     }
  78
  79     @Override
  80     public void setName(String name)
  81     {
  82         super.setName(name);
  83         this.tileCountName = this.getName() + " Tiles";
  84     }
  85
  86     public boolean isUseTransparentTextures()
  87     {
  88         return this.useTransparentTextures;
  89     }
  90
  91     public void setUseTransparentTextures(boolean useTransparentTextures)
  92     {
  93         this.useTransparentTextures = useTransparentTextures;
  94     }
  95
  96     public boolean isForceLevelZeroLoads()
  97     {
  98         return this.forceLevelZeroLoads;
  99     }
 100
 101     public void setForceLevelZeroLoads(boolean forceLevelZeroLoads)
 102     {
 103         this.forceLevelZeroLoads = forceLevelZeroLoads;
 104     }
 105
 106     public boolean isRetainLevelZeroTiles()
 107     {
 108         return retainLevelZeroTiles;
 109     }
 110
 111     public void setRetainLevelZeroTiles(boolean retainLevelZeroTiles)
 112     {
 113         this.retainLevelZeroTiles = retainLevelZeroTiles;
 114     }
 115
 116     public boolean isDrawTileIDs()
 117     {
 118         return drawTileIDs;
 119     }
 120
 121     public void setDrawTileIDs(boolean drawTileIDs)
 122     {
 123         this.drawTileIDs = drawTileIDs;
 124     }
 125
 126     public boolean isDrawTileBoundaries()
 127     {
 128         return drawTileBoundaries;
 129     }
 130
 131     public void setDrawTileBoundaries(boolean drawTileBoundaries)
 132     {
 133         this.drawTileBoundaries = drawTileBoundaries;
 134     }
 135
 136     public boolean isShowImageTileOutlines()
 137     {
 138         return showImageTileOutlines;
 139     }
 140
 141     public void setShowImageTileOutlines(boolean showImageTileOutlines)
 142     {
 143         this.showImageTileOutlines = showImageTileOutlines;
 144     }
 145
 146     public boolean isDrawBoundingVolumes()
 147     {
 148         return drawBoundingVolumes;
 149     }
 150
 151     public void setDrawBoundingVolumes(boolean drawBoundingVolumes)
 152     {
 153         this.drawBoundingVolumes = drawBoundingVolumes;
 154     }
 155
 156     protected LevelSet getLevels()
 157     {
 158         return levels;
 159     }
 160
 161     protected void setSplitScale(double splitScale)
 162     {
 163         this.splitScale = splitScale;
 164     }
 165
 166     protected PriorityBlockingQueue<Runnable> getRequestQ()
 167     {
 168         return requestQ;
 169     }
 170
 171     public boolean isMultiResolution()
 172     {
 173         return this.getLevels() != null && this.getLevels().getNumLevels() > 1;
 174     }
 175
 176     public boolean isAtMaxResolution()
 177     {
 178         return this.atMaxResolution;
 179     }
 180
 181     private void createTopLevelTiles()
 182     {
 183         Sector sector = this.levels.getSector();
 184
 185         Angle dLat = this.levels.getLevelZeroTileDelta().getLatitude();
 186         Angle dLon = this.levels.getLevelZeroTileDelta().getLongitude();
 187
 188         // Determine the row and column offset from the common World Wind global tiling origin.
 189         Level level = levels.getFirstLevel();
 190         int firstRow = Tile.computeRow(level.getTileDelta().getLatitude(), sector.getMinLatitude());
 191         int firstCol = Tile.computeColumn(level.getTileDelta().getLongitude(), sector.getMinLongitude());
 192         int lastRow = Tile.computeRow(level.getTileDelta().getLatitude(), sector.getMaxLatitude());
 193         int lastCol = Tile.computeColumn(level.getTileDelta().getLongitude(), sector.getMaxLongitude());
 194
 195         int nLatTiles = lastRow - firstRow + 1;
 196         int nLonTiles = lastCol - firstCol + 1;
 197
 198         this.topLevels = new ArrayList<TextureTile>(nLatTiles * nLonTiles);
 199
 200         Angle p1 = Tile.computeRowLatitude(firstRow, dLat);
 201         for (int row = firstRow; row <= lastRow; row++)
 202         {
 203             Angle p2;
 204             p2 = p1.add(dLat);
 205
 206             Angle t1 = Tile.computeColumnLongitude(firstCol, dLon);
 207             for (int col = firstCol; col <= lastCol; col++)
 208             {
 209                 Angle t2;
 210                 t2 = t1.add(dLon);
 211
 212                 this.topLevels.add(new TextureTile(new Sector(p1, p2, t1, t2), level, row, col));
 213                 t1 = t2;
 214             }
 215             p1 = p2;
 216         }
 217     }
 218
 219     private void loadAllTopLevelTextures(DrawContext dc)
 220     {
 221         for (TextureTile tile : this.topLevels)
 222         {
 223             if (!tile.isTextureInMemory(dc.getTextureCache()))
 224                 this.forceTextureLoad(tile);
 225         }
 226
 227         this.levelZeroLoaded = true;
 228     }
 229
 230     // ============== Tile Assembly ======================= //
 231     // ============== Tile Assembly ======================= //
 232     // ============== Tile Assembly ======================= //
 233
 234     private void assembleTiles(DrawContext dc)
 235     {
 236         this.currentTiles.clear();
 237
 238         for (TextureTile tile : this.topLevels)
 239         {
 240             if (this.isTileVisible(dc, tile))
 241             {
 242                 this.currentResourceTile = null;
 243                 this.addTileOrDescendants(dc, tile);
 244             }
 245         }
 246     }
 247
 248     private void addTileOrDescendants(DrawContext dc, TextureTile tile)
 249     {
 250         if (this.meetsRenderCriteria(dc, tile))
 251         {
 252             this.addTile(dc, tile);
 253             return;
 254         }
 255
 256         // The incoming tile does not meet the rendering criteria, so it must be subdivided and those
 257         // subdivisions tested against the criteria.
 258
 259         // All tiles that meet the selection criteria are drawn, but some of those tiles will not have
 260         // textures associated with them either because their texture isn't loaded yet or because they
 261         // are finer grain than the layer has textures for. In these cases the tiles use the texture of
 262         // the closest ancestor that has a texture loaded. This ancestor is called the currentResourceTile.
 263         // A texture transform is applied during rendering to align the sector's texture coordinates with the
 264         // appropriate region of the ancestor's texture.
 265
 266         TextureTile ancestorResource = null;
 267
 268         try
 269         {
 270             // At this point the tile does not meet the render criteria but it may have its texture in memory.
 271             // If so, register this tile as the resource tile. If not, then this tile will be the next level
 272             // below a tile with texture in memory. So to provide progressive resolution increase, add this tile
 273             // to the draw list. That will cause the tile to be drawn using its parent tile's texture, and it will
 274             // cause it's texture to be requested. At some future call to this method the tile's texture will be in
 275             // memory, it will not meet the render criteria, but will serve as the parent to a tile that goes
 276             // through this same process as this method recurses. The result of all this is that a tile isn't rendered
 277             // with its own texture unless all its parents have their textures loaded. In addition to causing
 278             // progressive resolution increase, this ensures that the parents are available as the user zooms out, and
 279             // therefore the layer remains visible until the user is zoomed out to the point the layer is no longer
 280             // active.
 281             if (tile.isTextureInMemory(dc.getTextureCache()) || tile.getLevelNumber() == 0)
 282             {
 283                 ancestorResource = this.currentResourceTile;
 284                 this.currentResourceTile = tile;
 285             }
 286             else if (!tile.getLevel().isEmpty())
 287             {
 288                 this.addTile(dc, tile);
 289                 return;
 290             }
 291
 292             TextureTile[] subTiles = tile.createSubTiles(this.levels.getLevel(tile.getLevelNumber() + 1));
 293             for (TextureTile child : subTiles)
 294             {
 295                 if (this.isTileVisible(dc, child))
 296                     this.addTileOrDescendants(dc, child);
 297             }
 298         }
 299         finally
 300         {
 301             if (ancestorResource != null) // Pop this tile as the currentResource ancestor
 302                 this.currentResourceTile = ancestorResource;
 303         }
 304     }
 305
 306     private void addTile(DrawContext dc, TextureTile tile)
 307     {
 308         tile.setFallbackTile(null);
 309
 310         if (tile.isTextureInMemory(dc.getTextureCache()))
 311         {
 312 //            System.out.printf("Sector %s, min = %f, max = %f\n", tile.getSector(),
 313 //                dc.getGlobe().getMinElevation(tile.getSector()), dc.getGlobe().getMaxElevation(tile.getSector()));
 314             this.addTileToCurrent(tile);
 315             return;
 316         }
 317
 318         // Level 0 loads may be forced
 319         if (tile.getLevelNumber() == 0 && this.forceLevelZeroLoads && !tile.isTextureInMemory(dc.getTextureCache()))
 320         {
 321             this.forceTextureLoad(tile);
 322             if (tile.isTextureInMemory(dc.getTextureCache()))
 323             {
 324                 this.addTileToCurrent(tile);
 325                 return;
 326             }
 327         }
 328
 329         // Tile's texture isn't available, so request it
 330         if (tile.getLevelNumber() < this.levels.getNumLevels())
 331         {
 332             // Request only tiles with data associated at this level
 333             if (!this.levels.isResourceAbsent(tile))
 334                 this.requestTexture(dc, tile);
 335         }
 336
 337         // Set up to use the currentResource tile's texture
 338         if (this.currentResourceTile != null)
 339         {
 340             if (this.currentResourceTile.getLevelNumber() == 0 && this.forceLevelZeroLoads &&
 341                 !this.currentResourceTile.isTextureInMemory(dc.getTextureCache()) &&
 342                 !this.currentResourceTile.isTextureInMemory(dc.getTextureCache()))
 343                 this.forceTextureLoad(this.currentResourceTile);
 344
 345             if (this.currentResourceTile.isTextureInMemory(dc.getTextureCache()))
 346             {
 347                 tile.setFallbackTile(currentResourceTile);
 348                 this.addTileToCurrent(tile);
 349             }
 350         }
 351     }
 352
 353     private void addTileToCurrent(TextureTile tile)
 354     {
 355         this.currentTiles.add(tile);
 356     }
 357
 358     private boolean isTileVisible(DrawContext dc, TextureTile tile)
 359     {
 360 //        if (!(tile.getExtent(dc).intersects(dc.getView().getFrustumInModelCoordinates())
 361 //            && (dc.getVisibleSector() == null || dc.getVisibleSector().intersects(tile.getSector()))))
 362 //            return false;
 363 //
 364 //        Position eyePos = dc.getView().getEyePosition();
 365 //        LatLon centroid = tile.getSector().getCentroid();
 366 //        Angle d = LatLon.sphericalDistance(eyePos.getLatLon(), centroid);
 367 //        if ((!tile.getLevelName().equals("0")) && d.compareTo(tile.getSector().getDeltaLat().multiply(2.5)) == 1)
 368 //            return false;
 369 //
 370 //        return true;
 371 //
 372         return tile.getExtent(dc).intersects(dc.getView().getFrustumInModelCoordinates()) &&
 373             (dc.getVisibleSector() == null || dc.getVisibleSector().intersects(tile.getSector()));
 374     }
 375 //
 376 //    private boolean meetsRenderCriteria2(DrawContext dc, TextureTile tile)
 377 //    {
 378 //        if (this.levels.isFinalLevel(tile.getLevelNumber()))
 379 //            return true;
 380 //
 381 //        Sector sector = tile.getSector();
 382 //        Vec4[] corners = sector.computeCornerPoints(dc.getGlobe());
 383 //        Vec4 centerPoint = sector.computeCenterPoint(dc.getGlobe());
 384 //
 385 //        View view = dc.getView();
 386 //        double d1 = view.getEyePoint().distanceTo3(corners[0]);
 387 //        double d2 = view.getEyePoint().distanceTo3(corners[1]);
 388 //        double d3 = view.getEyePoint().distanceTo3(corners[2]);
 389 //        double d4 = view.getEyePoint().distanceTo3(corners[3]);
 390 //        double d5 = view.getEyePoint().distanceTo3(centerPoint);
 391 //
 392 //        double minDistance = d1;
 393 //        if (d2 < minDistance)
 394 //            minDistance = d2;
 395 //        if (d3 < minDistance)
 396 //            minDistance = d3;
 397 //        if (d4 < minDistance)
 398 //            minDistance = d4;
 399 //        if (d5 < minDistance)
 400 //            minDistance = d5;
 401 //
 402 //        double r = 0;
 403 //        if (minDistance == d1)
 404 //            r = corners[0].getLength3();
 405 //        if (minDistance == d2)
 406 //            r = corners[1].getLength3();
 407 //        if (minDistance == d3)
 408 //            r = corners[2].getLength3();
 409 //        if (minDistance == d4)
 410 //            r = corners[3].getLength3();
 411 //        if (minDistance == d5)
 412 //            r = centerPoint.getLength3();
 413 //
 414 //        double texelSize = tile.getLevel().getTexelSize(r);
 415 //        double pixelSize = dc.getView().computePixelSizeAtDistance(minDistance);
 416 //
 417 //        return 2 * pixelSize >= texelSize;
 418 //    }
 419
 420     private boolean meetsRenderCriteria(DrawContext dc, TextureTile tile)
 421     {
 422         return this.levels.isFinalLevel(tile.getLevelNumber()) || !needToSplit(dc, tile.getSector());
 423     }
 424
 425     private boolean needToSplit(DrawContext dc, Sector sector)
 426     {
 427         Vec4[] corners = sector.computeCornerPoints(dc.getGlobe());
 428         Vec4 centerPoint = sector.computeCenterPoint(dc.getGlobe());
 429
 430         View view = dc.getView();
 431         double d1 = view.getEyePoint().distanceTo3(corners[0]);
 432         double d2 = view.getEyePoint().distanceTo3(corners[1]);
 433         double d3 = view.getEyePoint().distanceTo3(corners[2]);
 434         double d4 = view.getEyePoint().distanceTo3(corners[3]);
 435         double d5 = view.getEyePoint().distanceTo3(centerPoint);
 436
 437         double minDistance = d1;
 438         if (d2 < minDistance)
 439             minDistance = d2;
 440         if (d3 < minDistance)
 441             minDistance = d3;
 442         if (d4 < minDistance)
 443             minDistance = d4;
 444         if (d5 < minDistance)
 445             minDistance = d5;
 446
 447         double cellSize = (Math.PI * sector.getDeltaLatRadians() * dc.getGlobe().getRadius()) / 20; // TODO
 448
 449         return !(Math.log10(cellSize) <= (Math.log10(minDistance) - this.splitScale));
 450     }
 451
 452     private boolean atMaxLevel(DrawContext dc)
 453     {
 454         Position vpc = dc.getViewportCenterPosition();
 455         if (dc.getView() == null || this.getLevels() == null || vpc == null)
 456             return false;
 457
 458         if (!this.getLevels().getSector().contains(vpc.getLatitude(), vpc.getLongitude()))
 459             return true;
 460
 461         Level nextToLast = this.getLevels().getNextToLastLevel();
 462         if (nextToLast == null)
 463             return true;
 464
 465         Sector centerSector = nextToLast.computeSectorForPosition(vpc.getLatitude(), vpc.getLongitude());
 466         return this.needToSplit(dc, centerSector);
 467     }
 468
 469     // ============== Rendering ======================= //
 470     // ============== Rendering ======================= //
 471     // ============== Rendering ======================= //
 472
 473     @Override
 474     public void render(DrawContext dc)
 475     {
 476         this.atMaxResolution = this.atMaxLevel(dc);
 477         super.render(dc);
 478     }
 479
 480     @Override
 481     protected final void doRender(DrawContext dc)
 482     {
 483         if (this.forceLevelZeroLoads && !this.levelZeroLoaded)
 484             this.loadAllTopLevelTextures(dc);
 485         if (dc.getSurfaceGeometry() == null || dc.getSurfaceGeometry().size() < 1)
 486             return; // TODO: throw an illegal state exception?
 487
 488         dc.getGeographicSurfaceTileRenderer().setShowImageTileOutlines(this.showImageTileOutlines);
 489
 490         draw(dc);
 491     }
 492
 493     private void draw(DrawContext dc)
 494     {
 495         this.referencePoint = this.computeReferencePoint(dc);
 496
 497         this.assembleTiles(dc); // Determine the tiles to draw.
 498
 499         if (this.currentTiles.size() >= 1)
 500         {
 501             TextureTile[] sortedTiles = new TextureTile[this.currentTiles.size()];
 502             sortedTiles = this.currentTiles.toArray(sortedTiles);
 503             Arrays.sort(sortedTiles, levelComparer);
 504
 505             GL gl = dc.getGL();
 506
 507             if (this.isUseTransparentTextures() || this.getOpacity() < 1)
 508             {
 509                 gl.glPushAttrib(GL.GL_COLOR_BUFFER_BIT | GL.GL_POLYGON_BIT | GL.GL_CURRENT_BIT);
 510                 gl.glColor4d(1d, 1d, 1d, this.getOpacity());
 511                 gl.glEnable(GL.GL_BLEND);
 512                 gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
 513             }
 514             else
 515             {
 516                 gl.glPushAttrib(GL.GL_COLOR_BUFFER_BIT | GL.GL_POLYGON_BIT);
 517             }
 518
 519             gl.glPolygonMode(GL.GL_FRONT, GL.GL_FILL);
 520             gl.glEnable(GL.GL_CULL_FACE);
 521             gl.glCullFace(GL.GL_BACK);
 522
 523             dc.setPerFrameStatistic(PerformanceStatistic.IMAGE_TILE_COUNT, this.tileCountName,
 524                 this.currentTiles.size());
 525             dc.getGeographicSurfaceTileRenderer().renderTiles(dc, this.currentTiles);
 526
 527             gl.glPopAttrib();
 528
 529             if (this.drawTileIDs)
 530                 this.drawTileIDs(dc, this.currentTiles);
 531
 532             if (this.drawBoundingVolumes)
 533                 this.drawBoundingVolumes(dc, this.currentTiles);
 534
 535             this.currentTiles.clear();
 536         }
 537
 538         this.sendRequests();
 539         this.requestQ.clear();
 540     }
 541
 542     private void sendRequests()
 543     {
 544         Runnable task = this.requestQ.poll();
 545         while (task != null)
 546         {
 547             if (!WorldWind.getTaskService().isFull())
 548             {
 549                 WorldWind.getTaskService().addTask(task);
 550             }
 551             task = this.requestQ.poll();
 552         }
 553     }
 554
 555     public boolean isLayerInView(DrawContext dc)
 556     {
 557         if (dc == null)
 558         {
 559             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 560             Logging.logger().severe(message);
 561             throw new IllegalStateException(message);
 562         }
 563
 564         if (dc.getView() == null)
 565         {
 566             String message = Logging.getMessage("layers.AbstractLayer.NoViewSpecifiedInDrawingContext");
 567             Logging.logger().severe(message);
 568             throw new IllegalStateException(message);
 569         }
 570
 571         return !(dc.getVisibleSector() != null && !this.levels.getSector().intersects(dc.getVisibleSector()));
 572     }
 573
 574     private Vec4 computeReferencePoint(DrawContext dc)
 575     {
 576         if (dc.getViewportCenterPosition() != null)
 577             return dc.getGlobe().computePointFromPosition(dc.getViewportCenterPosition());
 578
 579         java.awt.geom.Rectangle2D viewport = dc.getView().getViewport();
 580         int x = (int) viewport.getWidth() / 2;
 581         for (int y = (int) (0.5 * viewport.getHeight()); y >= 0; y--)
 582         {
 583             Position pos = dc.getView().computePositionFromScreenPoint(x, y);
 584             if (pos == null)
 585                 continue;
 586
 587             return dc.getGlobe().computePointFromPosition(pos.getLatitude(), pos.getLongitude(), 0d);
 588         }
 589
 590         return null;
 591     }
 592
 593     protected Vec4 getReferencePoint()
 594     {
 595         return this.referencePoint;
 596     }
 597
 598     private static class LevelComparer implements Comparator<TextureTile>
 599     {
 600         public int compare(TextureTile ta, TextureTile tb)
 601         {
 602             int la = ta.getFallbackTile() == null ? ta.getLevelNumber() : ta.getFallbackTile().getLevelNumber();
 603             int lb = tb.getFallbackTile() == null ? tb.getLevelNumber() : tb.getFallbackTile().getLevelNumber();
 604
 605             return la < lb ? -1 : la == lb ? 0 : 1;
 606         }
 607     }
 608
 609     private void drawTileIDs(DrawContext dc, ArrayList<TextureTile> tiles)
 610     {
 611         java.awt.Rectangle viewport = dc.getView().getViewport();
 612         if (this.textRenderer == null)
 613             this.textRenderer = new TextRenderer(java.awt.Font.decode("Arial-Plain-13"), true, true);
 614
 615         dc.getGL().glDisable(GL.GL_DEPTH_TEST);
 616         dc.getGL().glDisable(GL.GL_BLEND);
 617         dc.getGL().glDisable(GL.GL_TEXTURE_2D);
 618
 619         this.textRenderer.setColor(java.awt.Color.YELLOW);
 620         this.textRenderer.beginRendering(viewport.width, viewport.height);
 621         for (TextureTile tile : tiles)
 622         {
 623             String tileLabel = tile.getLabel();
 624
 625             if (tile.getFallbackTile() != null)
 626                 tileLabel += "/" + tile.getFallbackTile().getLabel();
 627
 628             LatLon ll = tile.getSector().getCentroid();
 629             Vec4 pt = dc.getGlobe().computePointFromPosition(ll.getLatitude(), ll.getLongitude(),
 630                 dc.getGlobe().getElevation(ll.getLatitude(), ll.getLongitude()));
 631             pt = dc.getView().project(pt);
 632             this.textRenderer.draw(tileLabel, (int) pt.x, (int) pt.y);
 633         }
 634         this.textRenderer.endRendering();
 635     }
 636
 637     private void drawBoundingVolumes(DrawContext dc, ArrayList<TextureTile> tiles)
 638     {
 639         float[] previousColor = new float[4];
 640         dc.getGL().glGetFloatv(GL.GL_CURRENT_COLOR, previousColor, 0);
 641         dc.getGL().glColor3d(0, 1, 0);
 642
 643         for (TextureTile tile : tiles)
 644         {
 645             ((Cylinder) tile.getExtent(dc)).render(dc);
 646         }
 647
 648         Cylinder c =
 649             dc.getGlobe().computeBoundingCylinder(dc.getVerticalExaggeration(), this.levels.getSector());
 650         dc.getGL().glColor3d(1, 1, 0);
 651         c.render(dc);
 652
 653         dc.getGL().glColor4fv(previousColor, 0);
 654     }
 655 //
 656 //    private TextureTile getContainingTile(TextureTile tile, Angle latitude, Angle longitude, int levelNumber)
 657 //    {
 658 //        if (!tile.getSector().contains(latitude, longitude))
 659 //            return null;
 660 //
 661 //        if (tile.getLevelNumber() == levelNumber || this.levels.isFinalLevel(tile.getLevelNumber()))
 662 //            return tile;
 663 //
 664 //        TextureTile containingTile;
 665 //        TextureTile[] subTiles = tile.createSubTiles(this.levels.getLevel(tile.getLevelNumber() + 1));
 666 //        for (TextureTile child : subTiles)
 667 //        {
 668 //            containingTile = this.getContainingTile(child, latitude, longitude, levelNumber);
 669 //            if (containingTile != null)
 670 //                return containingTile;
 671 //        }
 672 //
 673 //        return null;
 674 //    }
 675
 676     // ============== Image Composition ======================= //
 677     // ============== Image Composition ======================= //
 678     // ============== Image Composition ======================= //
 679
 680     private final static String[] formats = new String[] {"jpg", "jpeg", "png", "tiff"};
 681     private final static String[] suffixes = new String[] {".jpg", ".jpg", ".png", ".tiff"};
 682
 683     private BufferedImage requestImage(TextureTile tile)
 684     {
 685         URL url = null;
 686         String pathBase = tile.getPath().substring(0, tile.getPath().lastIndexOf("."));
 687         for (String suffix : suffixes)
 688         {
 689             String path = pathBase + suffix;
 690             url = WorldWind.getDataFileCache().findFile(path, false);
 691             if (url != null)
 692                 break;
 693         }
 694
 695         if (url == null)
 696             return null;
 697
 698         if (WWIO.isFileOutOfDate(url, tile.getLevel().getExpiryTime()))
 699         {
 700             // The file has expired. Delete it then request download of newer.
 701             WorldWind.getDataFileCache().removeFile(url);
 702             String message = Logging.getMessage("generic.DataFileExpired", url);
 703             Logging.logger().fine(message);
 704         }
 705         else
 706         {
 707             try
 708             {
 709                 BufferedImage image = ImageIO.read(new File(url.toURI()));
 710                 if (image == null)
 711                 {
 712                     return null; // TODO: warn
 713                 }
 714
 715                 this.levels.unmarkResourceAbsent(tile);
 716                 return image;
 717             }
 718             catch (IOException e)
 719             {
 720                 // Assume that something's wrong with the file and delete it.
 721                 gov.nasa.worldwind.WorldWind.getDataFileCache().removeFile(url);
 722                 this.levels.markResourceAbsent(tile);
 723                 String message = Logging.getMessage("generic.DeletedCorruptDataFile", url);
 724                 Logging.logger().info(message);
 725             }
 726             catch (URISyntaxException e)
 727             {
 728                 e.printStackTrace(); // TODO
 729             }
 730         }
 731
 732         return null;
 733     }
 734
 735     private void downloadImage(final TextureTile tile)
 736     {
 737         try
 738         {
 739             String urlString = tile.getResourceURL().toExternalForm().replace("dds", "");
 740             final URL resourceURL = new URL(urlString);
 741             Retriever retriever;
 742
 743             String protocol = resourceURL.getProtocol();
 744
 745             if ("http".equalsIgnoreCase(protocol))
 746             {
 747                 retriever = new HTTPRetriever(resourceURL, new HttpRetrievalPostProcessor(tile));
 748             }
 749             else
 750             {
 751                 // TODO:
 752                 Logging.logger().severe(
 753                     Logging.getMessage("layers.TextureLayer.UnknownRetrievalProtocol", resourceURL));
 754                 return;
 755             }
 756
 757             retriever.call();
 758         }
 759         catch (Exception e)
 760         {
 761             e.printStackTrace(); // TODO
 762         }
 763     }
 764
 765     private static class ImageSector
 766     {
 767         private final BufferedImage image;
 768         private final Sector sector;
 769
 770         public ImageSector(BufferedImage image, Sector sector)
 771         {
 772             this.image = image;
 773             this.sector = sector;
 774         }
 775     }
 776
 777     public BufferedImage composeImageForSector(Sector sector, int imageSize)
 778     {
 779         return this.composeImageForSector(sector, imageSize, -1);
 780     }
 781
 782     public BufferedImage composeImageForSector(Sector sector, int imageSize, int levelNumber)
 783     {
 784         TiledImageLayer.ImageSector[][] imageSectors = this.getImagesInSector(sector, levelNumber);
 785
 786         if (imageSectors == null)
 787         {
 788             System.out.println("No images available."); // TODO
 789             return null;
 790         }
 791
 792         Sector actualSector = null;
 793         for (TiledImageLayer.ImageSector[] isa : imageSectors)
 794         {
 795             for (TiledImageLayer.ImageSector is : isa)
 796             {
 797                 actualSector = Sector.union(actualSector, is.sector);
 798             }
 799         }
 800
 801         int ny = imageSectors.length;
 802         int nx = imageSectors[0].length;
 803
 804         int overallHeight = ny * imageSectors[0][0].image.getHeight();
 805         int overallWidth = nx * imageSectors[0][0].image.getWidth();
 806
 807         int tileWidth;
 808         int tileHeight;
 809         if (overallHeight >= overallWidth)
 810         {
 811             tileHeight = imageSize / ny;
 812             double aspect = (double) overallWidth / (double) overallHeight;
 813             tileWidth = (int) (aspect * imageSize / nx);
 814         }
 815         else
 816         {
 817             tileWidth = imageSize / nx;
 818             double aspect = (double) overallHeight / (double) overallWidth;
 819             tileHeight = (int) (aspect * imageSize / ny);
 820         }
 821
 822         int imageHeight = tileHeight * imageSectors.length;
 823         int imageWidth = tileWidth * imageSectors[0].length;
 824
 825         //noinspection ConstantConditions
 826         double sh = 1 / sector.getDeltaLat().divide(actualSector.getDeltaLat());
 827         double sw = 1 / sector.getDeltaLon().divide(actualSector.getDeltaLon());
 828         double dh = -(actualSector.getMaxLatitude().subtract(sector.getMaxLatitude()).divide(actualSector.getDeltaLat())
 829             * imageHeight);
 830         double dw = -(
 831             sector.getMinLongitude().subtract(actualSector.getMinLongitude()).divide(actualSector.getDeltaLon())
 832                 * imageWidth);
 833
 834         BufferedImage image = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_RGB);
 835         Graphics2D g = image.createGraphics();
 836         g.scale(sw, sh);
 837         g.translate(dw, dh);
 838
 839         int y = 0;
 840         for (TiledImageLayer.ImageSector[] row : imageSectors)
 841         {
 842             int x = 0;
 843             for (TiledImageLayer.ImageSector is : row)
 844             {
 845                 Image img = is.image.getScaledInstance(tileWidth, tileHeight, Image.SCALE_SMOOTH);
 846                 g.drawImage(img, x, y, null);
 847                 x += tileWidth;
 848             }
 849             y += tileHeight;
 850         }
 851
 852         return image;
 853     }
 854
 855     private ImageSector[][] getImagesInSector(Sector sector, int levelNumber)
 856     {
 857         if (sector == null)
 858         {
 859             String msg = Logging.getMessage("nullValue.SectorIsNull");
 860             Logging.logger().severe(msg);
 861             throw new IllegalArgumentException(msg);
 862         }
 863
 864         // TODO: check level number arg
 865
 866         Level targetLevel = this.levels.getLastLevel();
 867         if (levelNumber >= 0)
 868         {
 869             for (int i = levelNumber; i < this.getLevels().getLastLevel().getLevelNumber(); i++)
 870             {
 871                 if (this.levels.isLevelEmpty(i))
 872                     continue;
 873
 874                 targetLevel = this.levels.getLevel(i);
 875                 break;
 876             }
 877         }
 878
 879         // Collect all the tiles intersecting the input sector.
 880         LatLon delta = targetLevel.getTileDelta();
 881         final int nwRow = Tile.computeRow(delta.getLatitude(), sector.getMaxLatitude());
 882         final int nwCol = Tile.computeColumn(delta.getLongitude(), sector.getMinLongitude());
 883         final int seRow = Tile.computeRow(delta.getLatitude(), sector.getMinLatitude());
 884         final int seCol = Tile.computeColumn(delta.getLongitude(), sector.getMaxLongitude());
 885
 886         int numRows = nwRow - seRow + 1;
 887         int numCols = seCol - nwCol + 1;
 888         ImageSector[][] imageSectors = new ImageSector[numRows][numCols];
 889
 890         for (int row = nwRow; row >= seRow; row--)
 891         {
 892             for (int col = nwCol; col <= seCol; col++)
 893             {
 894                 TileKey key = new TileKey(targetLevel.getLevelNumber(), row, col, targetLevel.getCacheName());
 895                 Sector tileSector = this.levels.computeSectorForKey(key);
 896                 TextureTile textureTile = new TextureTile(tileSector, targetLevel, row, col);
 897                 BufferedImage image = this.getImage(textureTile);
 898                 if (image != null)
 899                     imageSectors[nwRow - row][col - nwCol] = new ImageSector(image, textureTile.getSector());
 900             }
 901         }
 902
 903         return imageSectors;
 904     }
 905
 906     private BufferedImage getImage(TextureTile tile)
 907     {
 908         // TODO: check args
 909
 910         // Read the image from disk.
 911         BufferedImage image = this.requestImage(tile);
 912         if (image != null)
 913             return image;
 914
 915         // Retrieve it from the net since it's not on disk.
 916         for (int i = 0; i < 10; i++)
 917         {
 918             this.downloadImage(tile);
 919
 920             // Try to read from disk again after retrieving it from the net.
 921             image = this.requestImage(tile);
 922             if (image != null)
 923                 return image;
 924         }
 925
 926         // All attempts to find the image have failed.
 927         return null;
 928     }
 929
 930     private class HttpRetrievalPostProcessor implements RetrievalPostProcessor
 931     {
 932         private TextureTile tile;
 933
 934         public HttpRetrievalPostProcessor(TextureTile tile)
 935         {
 936             this.tile = tile;
 937         }
 938
 939         public ByteBuffer run(Retriever retriever)
 940         {
 941             if (!retriever.getState().equals(Retriever.RETRIEVER_STATE_SUCCESSFUL))
 942                 return null;
 943
 944             HTTPRetriever htr = (HTTPRetriever) retriever;
 945             if (htr.getResponseCode() == HttpURLConnection.HTTP_NO_CONTENT)
 946             {
 947                 // Mark tile as missing to avoid excessive attempts
 948                 TiledImageLayer.this.levels.markResourceAbsent(tile);
 949                 return null;
 950             }
 951
 952             if (htr.getResponseCode() != HttpURLConnection.HTTP_OK)
 953                 return null;
 954
 955             URLRetriever r = (URLRetriever) retriever;
 956             ByteBuffer buffer = r.getBuffer();
 957
 958             String suffix = null;
 959             for (int i = 0; i < formats.length; i++)
 960             {
 961                 if (htr.getContentType().toLowerCase().contains(formats[i]))
 962                 {
 963                     suffix = suffixes[i];
 964                     break;
 965                 }
 966             }
 967             if (suffix == null)
 968             {
 969                 return null; // TODO: logger error
 970             }
 971
 972             String path = tile.getPath().substring(0, tile.getPath().lastIndexOf("."));
 973             path += suffix;
 974
 975             final File outFile = WorldWind.getDataFileCache().newFile(path);
 976             if (outFile == null)
 977                 return null;
 978
 979             try
 980             {
 981                 WWIO.saveBuffer(buffer, outFile);
 982                 return buffer;
 983             }
 984             catch (IOException e)
 985             {
 986                 e.printStackTrace(); // TODO: logger error
 987                 return null;
 988             }
 989         }
 990     }
 991 }