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.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 2533 2007-08-13 05:59:08Z 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
  42     // Diagnostic flags
  43     private boolean showImageTileOutlines = false;
  44     private boolean drawTileBoundaries = false;
  45     private boolean useTransparentTextures = false;
  46     private boolean drawTileIDs = false;
  47     private boolean drawBoundingVolumes = false;
  48     private TextRenderer textRenderer = null;
  49
  50     // Stuff computed each frame
  51     private ArrayList<TextureTile> currentTiles = new ArrayList<TextureTile>();
  52     private TextureTile currentResourceTile;
  53     private Vec4 referencePoint;
  54     private PriorityBlockingQueue<Runnable> requestQ = new PriorityBlockingQueue<Runnable>(200);
  55
  56     abstract protected void requestTexture(DrawContext dc, TextureTile tile);
  57
  58     abstract protected void forceTextureLoad(TextureTile tile);
  59
  60     public TiledImageLayer(LevelSet levelSet)
  61     {
  62         if (levelSet == null)
  63         {
  64             String message = Logging.getMessage("nullValue.LevelSetIsNull");
  65             Logging.logger().severe(message);
  66             throw new IllegalArgumentException(message);
  67         }
  68
  69         this.levels = new LevelSet(levelSet); // the caller's levelSet may change internally, so we copy it.
  70
  71         this.createTopLevelTiles();
  72
  73         this.setPickEnabled(false); // textures are assumed to be terrain unless specifically indicated otherwise.
  74         this.tileCountName = this.getName() + " Tiles";
  75     }
  76
  77     @Override
  78     public void setName(String name)
  79     {
  80         super.setName(name);
  81         this.tileCountName = this.getName() + " Tiles";
  82     }
  83
  84     public boolean isUseTransparentTextures()
  85     {
  86         return this.useTransparentTextures;
  87     }
  88
  89     public void setUseTransparentTextures(boolean useTransparentTextures)
  90     {
  91         this.useTransparentTextures = useTransparentTextures;
  92     }
  93
  94     public boolean isForceLevelZeroLoads()
  95     {
  96         return this.forceLevelZeroLoads;
  97     }
  98
  99     public void setForceLevelZeroLoads(boolean forceLevelZeroLoads)
 100     {
 101         this.forceLevelZeroLoads = forceLevelZeroLoads;
 102     }
 103
 104     public boolean isRetainLevelZeroTiles()
 105     {
 106         return retainLevelZeroTiles;
 107     }
 108
 109     public void setRetainLevelZeroTiles(boolean retainLevelZeroTiles)
 110     {
 111         this.retainLevelZeroTiles = retainLevelZeroTiles;
 112     }
 113
 114     public boolean isDrawTileIDs()
 115     {
 116         return drawTileIDs;
 117     }
 118
 119     public void setDrawTileIDs(boolean drawTileIDs)
 120     {
 121         this.drawTileIDs = drawTileIDs;
 122     }
 123
 124     public boolean isDrawTileBoundaries()
 125     {
 126         return drawTileBoundaries;
 127     }
 128
 129     public void setDrawTileBoundaries(boolean drawTileBoundaries)
 130     {
 131         this.drawTileBoundaries = drawTileBoundaries;
 132     }
 133
 134     public boolean isShowImageTileOutlines()
 135     {
 136         return showImageTileOutlines;
 137     }
 138
 139     public void setShowImageTileOutlines(boolean showImageTileOutlines)
 140     {
 141         this.showImageTileOutlines = showImageTileOutlines;
 142     }
 143
 144     public boolean isDrawBoundingVolumes()
 145     {
 146         return drawBoundingVolumes;
 147     }
 148
 149     public void setDrawBoundingVolumes(boolean drawBoundingVolumes)
 150     {
 151         this.drawBoundingVolumes = drawBoundingVolumes;
 152     }
 153
 154     protected LevelSet getLevels()
 155     {
 156         return levels;
 157     }
 158
 159     protected PriorityBlockingQueue<Runnable> getRequestQ()
 160     {
 161         return requestQ;
 162     }
 163
 164     private void createTopLevelTiles()
 165     {
 166         Sector sector = this.levels.getSector();
 167
 168         Angle dLat = this.levels.getLevelZeroTileDelta().getLatitude();
 169         Angle dLon = this.levels.getLevelZeroTileDelta().getLongitude();
 170
 171         // Determine the row and column offset from the common World Wind global tiling origin.
 172         Level level = levels.getFirstLevel();
 173         int firstRow = Tile.computeRow(level.getTileDelta().getLatitude(), sector.getMinLatitude());
 174         int firstCol = Tile.computeColumn(level.getTileDelta().getLongitude(), sector.getMinLongitude());
 175         int lastRow = Tile.computeRow(level.getTileDelta().getLatitude(), sector.getMaxLatitude());
 176         int lastCol = Tile.computeColumn(level.getTileDelta().getLongitude(), sector.getMaxLongitude());
 177
 178         int nLatTiles = lastRow - firstRow + 1;
 179         int nLonTiles = lastCol - firstCol + 1;
 180
 181         this.topLevels = new ArrayList<TextureTile>(nLatTiles * nLonTiles);
 182
 183         Angle p1 = Tile.computeRowLatitude(firstRow, dLat);
 184         for (int row = firstRow; row <= lastRow; row++)
 185         {
 186             Angle p2;
 187             p2 = p1.add(dLat);
 188
 189             Angle t1 = Tile.computeColumnLongitude(firstCol, dLon);
 190             for (int col = firstCol; col <= lastCol; col++)
 191             {
 192                 Angle t2;
 193                 t2 = t1.add(dLon);
 194
 195                 this.topLevels.add(new TextureTile(new Sector(p1, p2, t1, t2), level, row, col));
 196                 t1 = t2;
 197             }
 198             p1 = p2;
 199         }
 200     }
 201
 202     private void loadAllTopLevelTextures(DrawContext dc)
 203     {
 204         for (TextureTile tile : this.topLevels)
 205         {
 206             if (!tile.isTextureInMemory(dc.getTextureCache()))
 207                 this.forceTextureLoad(tile);
 208         }
 209
 210         this.levelZeroLoaded = true;
 211     }
 212
 213     // ============== Tile Assembly ======================= //
 214     // ============== Tile Assembly ======================= //
 215     // ============== Tile Assembly ======================= //
 216
 217     private void assembleTiles(DrawContext dc)
 218     {
 219         this.currentTiles.clear();
 220
 221         for (TextureTile tile : this.topLevels)
 222         {
 223             if (this.isTileVisible(dc, tile))
 224             {
 225                 this.currentResourceTile = null;
 226                 this.addTileOrDescendants(dc, tile);
 227             }
 228         }
 229     }
 230
 231     private void addTileOrDescendants(DrawContext dc, TextureTile tile)
 232     {
 233         if (this.meetsRenderCriteria(dc, tile))
 234         {
 235             this.addTile(dc, tile);
 236             return;
 237         }
 238
 239         // The incoming tile does not meet the rendering criteria, so it must be subdivided and those
 240         // subdivisions tested against the criteria.
 241
 242         // All tiles that meet the selection criteria are drawn, but some of those tiles will not have
 243         // textures associated with them either because their texture isn't loaded yet or because they
 244         // are finer grain than the layer has textures for. In these cases the tiles use the texture of
 245         // the closest ancestor that has a texture loaded. This ancestor is called the currentResourceTile.
 246         // A texture transform is applied during rendering to align the sector's texture coordinates with the
 247         // appropriate region of the ancestor's texture.
 248
 249         TextureTile ancestorResource = null;
 250
 251         try
 252         {
 253             if (tile.isTextureInMemory(dc.getTextureCache()) || tile.getLevelNumber() == 0)
 254             {
 255                 ancestorResource = this.currentResourceTile;
 256                 this.currentResourceTile = tile;
 257             }
 258
 259             // Ensure that levels finer than the finest image have the finest image around
 260             // TODO: find finest level with a non-missing tile
 261             if (this.levels.isFinalLevel(tile.getLevelNumber()) && !tile.isTextureInMemory(dc.getTextureCache()))
 262                 this.requestTexture(dc, tile);
 263
 264             TextureTile[] subTiles = tile.createSubTiles(this.levels.getLevel(tile.getLevelNumber() + 1));
 265             for (TextureTile child : subTiles)
 266             {
 267                 if (this.isTileVisible(dc, child))
 268                     this.addTileOrDescendants(dc, child);
 269             }
 270         }
 271         finally
 272         {
 273             if (ancestorResource != null) // Pop this tile as the currentResource ancestor
 274                 this.currentResourceTile = ancestorResource;
 275         }
 276     }
 277
 278     private void addTile(DrawContext dc, TextureTile tile)
 279     {
 280         tile.setFallbackTile(null);
 281
 282         if (tile.isTextureInMemory(dc.getTextureCache()))
 283         {
 284             this.addTileToCurrent(tile);
 285             return;
 286         }
 287
 288         // Level 0 loads may be forced
 289         if (tile.getLevelNumber() == 0 && this.forceLevelZeroLoads && !tile.isTextureInMemory(dc.getTextureCache()))
 290         {
 291             this.forceTextureLoad(tile);
 292             if (tile.isTextureInMemory(dc.getTextureCache()))
 293             {
 294                 this.addTileToCurrent(tile);
 295                 return;
 296             }
 297         }
 298
 299         // Tile's texture isn't available, so request it
 300         if (tile.getLevelNumber() < this.levels.getNumLevels())
 301         {
 302             // Request only tiles with data associated at this level
 303             if (!this.levels.isResourceAbsent(tile))
 304                 this.requestTexture(dc, tile);
 305         }
 306
 307         // Set up to use the currentResource tile's texture
 308         if (this.currentResourceTile != null)
 309         {
 310             if (this.currentResourceTile.getLevelNumber() == 0 && this.forceLevelZeroLoads &&
 311                 !this.currentResourceTile.isTextureInMemory(dc.getTextureCache()) &&
 312                 !this.currentResourceTile.isTextureInMemory(dc.getTextureCache()))
 313                 this.forceTextureLoad(this.currentResourceTile);
 314
 315             if (this.currentResourceTile.isTextureInMemory(dc.getTextureCache()))
 316             {
 317                 tile.setFallbackTile(currentResourceTile);
 318                 this.addTileToCurrent(tile);
 319             }
 320         }
 321     }
 322
 323     private void addTileToCurrent(TextureTile tile)
 324     {
 325         this.currentTiles.add(tile);
 326     }
 327
 328     private boolean isTileVisible(DrawContext dc, TextureTile tile)
 329     {
 330         return tile.getExtent(dc).intersects(dc.getView().getFrustumInModelCoordinates()) &&
 331             (dc.getVisibleSector() == null || dc.getVisibleSector().intersects(tile.getSector()));
 332     }
 333
 334     private boolean meetsRenderCriteria(DrawContext dc, TextureTile tile)
 335     {
 336         return this.levels.isFinalLevel(tile.getLevelNumber()) || !needToSplit(dc, tile.getSector(), 20);
 337     }
 338
 339     private static boolean needToSplit(DrawContext dc, Sector sector, int density)
 340     {
 341         Vec4[] corners = sector.computeCornerPoints(dc.getGlobe());
 342         Vec4 centerPoint = sector.computeCenterPoint(dc.getGlobe());
 343
 344         View view = dc.getView();
 345         double d1 = view.getEyePoint().distanceTo3(corners[0]);
 346         double d2 = view.getEyePoint().distanceTo3(corners[1]);
 347         double d3 = view.getEyePoint().distanceTo3(corners[2]);
 348         double d4 = view.getEyePoint().distanceTo3(corners[3]);
 349         double d5 = view.getEyePoint().distanceTo3(centerPoint);
 350
 351         double minDistance = d1;
 352         if (d2 < minDistance)
 353             minDistance = d2;
 354         if (d3 < minDistance)
 355             minDistance = d3;
 356         if (d4 < minDistance)
 357             minDistance = d4;
 358         if (d5 < minDistance)
 359             minDistance = d5;
 360
 361         double cellSize = (Math.PI * sector.getDeltaLatRadians() * dc.getGlobe().getRadius()) / density;
 362
 363         return !(Math.log10(cellSize) <= (Math.log10(minDistance) - 1));
 364     }
 365
 366     // ============== Rendering ======================= //
 367     // ============== Rendering ======================= //
 368     // ============== Rendering ======================= //
 369
 370     @Override
 371     protected final void doRender(DrawContext dc)
 372     {
 373         if (this.forceLevelZeroLoads && !this.levelZeroLoaded)
 374             this.loadAllTopLevelTextures(dc);
 375         if (dc.getSurfaceGeometry() == null || dc.getSurfaceGeometry().size() < 1)
 376             return; // TODO: throw an illegal state exception?
 377
 378         dc.getGeographicSurfaceTileRenderer().setShowImageTileOutlines(this.showImageTileOutlines);
 379
 380         draw(dc);
 381     }
 382
 383     private void draw(DrawContext dc)
 384     {
 385         this.referencePoint = this.computeReferencePoint(dc);
 386
 387         this.assembleTiles(dc); // Determine the tiles to draw.
 388
 389         if (this.currentTiles.size() >= 1)
 390         {
 391             TextureTile[] sortedTiles = new TextureTile[this.currentTiles.size()];
 392             sortedTiles = this.currentTiles.toArray(sortedTiles);
 393             Arrays.sort(sortedTiles, levelComparer);
 394
 395             GL gl = dc.getGL();
 396
 397             gl.glPushAttrib(GL.GL_COLOR_BUFFER_BIT | GL.GL_POLYGON_BIT);
 398
 399             if (this.isUseTransparentTextures())
 400             {
 401                 gl.glEnable(GL.GL_BLEND);
 402                 gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
 403             }
 404
 405             gl.glPolygonMode(GL.GL_FRONT, GL.GL_FILL);
 406             gl.glEnable(GL.GL_CULL_FACE);
 407             gl.glCullFace(GL.GL_BACK);
 408
 409             dc.setPerFrameStatistic(PerformanceStatistic.IMAGE_TILE_COUNT, this.tileCountName, this.currentTiles.size());
 410             dc.getGeographicSurfaceTileRenderer().renderTiles(dc, this.currentTiles);
 411
 412             gl.glPopAttrib();
 413
 414             if (this.drawTileIDs)
 415                 this.drawTileIDs(dc, this.currentTiles);
 416
 417             if (this.drawBoundingVolumes)
 418                 this.drawBoundingVolumes(dc, this.currentTiles);
 419
 420             this.currentTiles.clear();
 421         }
 422
 423         this.sendRequests();
 424         this.requestQ.clear();
 425     }
 426
 427     private void sendRequests()
 428     {
 429         Runnable task = this.requestQ.poll();
 430         while (task != null)
 431         {
 432             if (!WorldWind.getTaskService().isFull())
 433             {
 434                 WorldWind.getTaskService().addTask(task);
 435             }
 436             task = this.requestQ.poll();
 437         }
 438     }
 439
 440     public boolean isLayerInView(DrawContext dc)
 441     {
 442         if (dc == null)
 443         {
 444             String message = Logging.getMessage("nullValue.DrawContextIsNull");
 445             Logging.logger().severe(message);
 446             throw new IllegalStateException(message);
 447         }
 448
 449         if (dc.getView() == null)
 450         {
 451             String message = Logging.getMessage("layers.AbstractLayer.NoViewSpecifiedInDrawingContext");
 452             Logging.logger().severe(message);
 453             throw new IllegalStateException(message);
 454         }
 455
 456         return !(dc.getVisibleSector() != null && !this.levels.getSector().intersects(dc.getVisibleSector()));
 457     }
 458
 459     private Vec4 computeReferencePoint(DrawContext dc)
 460     {
 461         java.awt.geom.Rectangle2D viewport = dc.getView().getViewport();
 462         int x = (int) viewport.getWidth() / 2;
 463         for (int y = (int) (0.75 * viewport.getHeight()); y >= 0; y--)
 464         {
 465             Position pos = dc.getView().computePositionFromScreenPoint(x, y);
 466             if (pos == null)
 467                 continue;
 468
 469             return dc.getGlobe().computePointFromPosition(pos.getLatitude(), pos.getLongitude(), 0d);
 470         }
 471
 472         return null;
 473     }
 474
 475     protected Vec4 getReferencePoint()
 476     {
 477         return this.referencePoint;
 478     }
 479
 480     private static class LevelComparer implements Comparator<TextureTile>
 481     {
 482         public int compare(TextureTile ta, TextureTile tb)
 483         {
 484             int la = ta.getFallbackTile() == null ? ta.getLevelNumber() : ta.getFallbackTile().getLevelNumber();
 485             int lb = tb.getFallbackTile() == null ? tb.getLevelNumber() : tb.getFallbackTile().getLevelNumber();
 486
 487             return la < lb ? -1 : la == lb ? 0 : 1;
 488         }
 489     }
 490
 491     private void drawTileIDs(DrawContext dc, ArrayList<TextureTile> tiles)
 492     {
 493         java.awt.Rectangle viewport = dc.getView().getViewport();
 494         if (this.textRenderer == null)
 495             this.textRenderer = new TextRenderer(java.awt.Font.decode("Arial-Plain-13"), true, true);
 496
 497         dc.getGL().glDisable(GL.GL_DEPTH_TEST);
 498         dc.getGL().glDisable(GL.GL_BLEND);
 499         dc.getGL().glDisable(GL.GL_TEXTURE_2D);
 500
 501         this.textRenderer.setColor(java.awt.Color.YELLOW);
 502         this.textRenderer.beginRendering(viewport.width, viewport.height);
 503         for (TextureTile tile : tiles)
 504         {
 505             String tileLabel = tile.getLabel();
 506
 507             if (tile.getFallbackTile() != null)
 508                 tileLabel += "/" + tile.getFallbackTile().getLabel();
 509
 510             LatLon ll = tile.getSector().getCentroid();
 511             Vec4 pt = dc.getGlobe().computePointFromPosition(ll.getLatitude(), ll.getLongitude(),
 512                 dc.getGlobe().getElevation(ll.getLatitude(), ll.getLongitude()));
 513             pt = dc.getView().project(pt);
 514             this.textRenderer.draw(tileLabel, (int) pt.x, (int) pt.y);
 515         }
 516         this.textRenderer.endRendering();
 517     }
 518
 519     private void drawBoundingVolumes(DrawContext dc, ArrayList<TextureTile> tiles)
 520     {
 521         float[] previousColor = new float[4];
 522         dc.getGL().glGetFloatv(GL.GL_CURRENT_COLOR, previousColor, 0);
 523         dc.getGL().glColor3d(0, 1, 0);
 524
 525         for (TextureTile tile : tiles)
 526         {
 527             ((Cylinder) tile.getExtent(dc)).render(dc);
 528         }
 529
 530         Cylinder c =
 531             Sector.computeBoundingCylinder(dc.getGlobe(), dc.getVerticalExaggeration(), this.levels.getSector());
 532         dc.getGL().glColor3d(1, 1, 0);
 533         c.render(dc);
 534
 535         dc.getGL().glColor4fv(previousColor, 0);
 536     }
 537
 538     // ============== Color Lookup ======================= //
 539     // ============== Color Lookup ======================= //
 540     // ============== Color Lookup ======================= //
 541
 542     public Color getColor(Angle latitude, Angle longitude, int levelNumber)
 543     {
 544         // TODO: check args
 545
 546         // Find the tile containing the position in the specified level.
 547         TextureTile containingTile = null;
 548         for (TextureTile tile : this.topLevels)
 549         {
 550             containingTile = this.getContainingTile(tile, latitude, longitude, levelNumber);
 551             if (containingTile != null)
 552                 break;
 553         }
 554         if (containingTile == null)
 555             return null;
 556
 557         String pathBase = containingTile.getPath().substring(0, containingTile.getPath().lastIndexOf("."));
 558         String cacheKey = pathBase + ".BufferedImage";
 559
 560         // Look up the color if the image is in memory.
 561         BufferedImage image = (BufferedImage) WorldWind.getMemoryCache("BatchTiles").getObject(cacheKey);
 562         if (image != null)
 563             return this.resolveColor(containingTile, image, latitude, longitude);
 564
 565         // Read the image from disk since it's not in memory.
 566         image = this.requestImage(containingTile, cacheKey);
 567         if (image != null)
 568             return this.resolveColor(containingTile, image, latitude, longitude);
 569
 570         // Retrieve it from the net since it's not on disk.
 571         this.downloadImage(containingTile);
 572
 573         // Try to read from disk again after retrieving it from the net.
 574         image = this.requestImage(containingTile, cacheKey);
 575         if (image != null)
 576             return this.resolveColor(containingTile, image, latitude, longitude);
 577
 578         // All attempts to find the image have failed.
 579         return null;
 580     }
 581
 582     private final static String[] formats = new String[]{"jpg", "jpeg", "png", "tiff"};
 583     private final static String[] suffixes = new String[]{".jpg", ".jpg", ".png", ".tiff"};
 584
 585     private BufferedImage requestImage(TextureTile tile, String cacheKey)
 586     {
 587         URL url = null;
 588         String pathBase = tile.getPath().substring(0, tile.getPath().lastIndexOf("."));
 589         for (String suffix : suffixes)
 590         {
 591             String path = pathBase + suffix;
 592             url = WorldWind.getDataFileCache().findFile(path, false);
 593             if (url != null)
 594                 break;
 595         }
 596
 597         if (url == null)
 598             return null;
 599
 600         if (WWIO.isFileOutOfDate(url, tile.getLevel().getExpiryTime()))
 601         {
 602             // The file has expired. Delete it then request download of newer.
 603             gov.nasa.worldwind.WorldWind.getDataFileCache().removeFile(url);
 604             String message = Logging.getMessage("generic.DataFileExpired", url);
 605             Logging.logger().fine(message);
 606         }
 607         else
 608         {
 609             try
 610             {
 611                 BufferedImage image = ImageIO.read(new File(url.toURI()));
 612                 if (image == null)
 613                 {
 614                     return null; // TODO: warn
 615                 }
 616
 617                 WorldWind.getMemoryCache("BatchTiles").add(cacheKey, image, image.getRaster().getDataBuffer().getSize());
 618                 this.levels.unmarkResourceAbsent(tile);
 619                 return image;
 620             }
 621             catch (IOException e)
 622             {
 623                 // Assume that something's wrong with the file and delete it.
 624                 gov.nasa.worldwind.WorldWind.getDataFileCache().removeFile(url);
 625                 this.levels.markResourceAbsent(tile);
 626                 String message = Logging.getMessage("generic.DeletedCorruptDataFile", url);
 627                 Logging.logger().info(message);
 628             }
 629             catch (URISyntaxException e)
 630             {
 631                 e.printStackTrace(); // TODO
 632             }
 633         }
 634
 635         return null;
 636     }
 637
 638     private void downloadImage(final TextureTile tile)
 639     {
 640         try
 641         {
 642             String urlString = tile.getResourceURL().toExternalForm().replace("dds", "");
 643             final URL resourceURL = new URL(urlString);
 644             Retriever retriever;
 645
 646             String protocol = resourceURL.getProtocol();
 647
 648             if ("http".equalsIgnoreCase(protocol))
 649             {
 650                 retriever = new HTTPRetriever(resourceURL, new HttpRetrievalPostProcessor(tile));
 651             }
 652             else
 653             {
 654                 // TODO:
 655                 Logging.logger().severe(
 656                     Logging.getMessage("layers.TextureLayer.UnknownRetrievalProtocol", resourceURL));
 657                 return;
 658             }
 659
 660             retriever.call();
 661         }
 662         catch (Exception e)
 663         {
 664             e.printStackTrace(); // TODO
 665         }
 666     }
 667
 668     private TextureTile getContainingTile(TextureTile tile, Angle latitude, Angle longitude, int levelNumber)
 669     {
 670         if (!tile.getSector().contains(latitude, longitude))
 671             return null;
 672
 673         if (tile.getLevelNumber() == levelNumber || this.levels.isFinalLevel(tile.getLevelNumber()))
 674             return tile;
 675
 676         TextureTile containingTile;
 677         TextureTile[] subTiles = tile.createSubTiles(this.levels.getLevel(tile.getLevelNumber() + 1));
 678         for (TextureTile child : subTiles)
 679         {
 680             containingTile = this.getContainingTile(child, latitude, longitude, levelNumber);
 681             if (containingTile != null)
 682                 return containingTile;
 683         }
 684
 685         return null;
 686     }
 687
 688     private Color resolveColor(TextureTile tile, BufferedImage image, Angle latitude, Angle longitude)
 689     {
 690         Sector sector = tile.getSector();
 691
 692         final double dLat = sector.getMaxLatitude().degrees - latitude.degrees;
 693         final double dLon = longitude.degrees - sector.getMinLongitude().degrees;
 694         final double sLat = dLat / sector.getDeltaLat().degrees;
 695         final double sLon = dLon / sector.getDeltaLon().degrees;
 696
 697         final int tileHeight = tile.getLevel().getTileHeight();
 698         final int tileWidth = tile.getLevel().getTileWidth();
 699         int x = (int) ((tileWidth - 1) * sLon);
 700         int y = (int) ((tileHeight - 1) * sLat);
 701         int w = x < (tileWidth - 1) ? 1 : 0;
 702         int h = y < (tileHeight - 1) ? 1 : 0;
 703
 704         double dh = sector.getDeltaLat().degrees / (tileHeight - 1);
 705         double dw = sector.getDeltaLon().degrees / (tileWidth - 1);
 706         double ssLat = (dLat - y * dh) / dh;
 707         double ssLon = (dLon - x * dw) / dw;
 708
 709         int sw = image.getRGB(x, y);
 710         int se = image.getRGB(x + w, y);
 711         int ne = image.getRGB(x + w, y + h);
 712         int nw = image.getRGB(x, y + h);
 713
 714         Color csw = new Color(sw);
 715         Color cse = new Color(se);
 716         Color cne = new Color(ne);
 717         Color cnw = new Color(nw);
 718
 719         Color ctop = interpolateColors(cnw, cne, ssLon);
 720         Color cbot = interpolateColors(csw, cse, ssLon);
 721
 722         return interpolateColors(cbot, ctop, ssLat);
 723     }
 724
 725     private Color interpolateColors(Color ca, Color cb, double s)
 726     {
 727         int r = (int) (s * ca.getRed() + (1 - s) * cb.getRed());
 728         int g = (int) (s * ca.getGreen() + (1 - s) * cb.getGreen());
 729         int b = (int) (s * ca.getBlue() + (1 - s) * cb.getBlue());
 730
 731         return new Color(r, g, b);
 732     }
 733
 734     private class HttpRetrievalPostProcessor implements RetrievalPostProcessor
 735     {
 736         private TextureTile tile;
 737
 738         public HttpRetrievalPostProcessor(TextureTile tile)
 739         {
 740             this.tile = tile;
 741         }
 742
 743         public ByteBuffer run(Retriever retriever)
 744         {
 745             if (!retriever.getState().equals(Retriever.RETRIEVER_STATE_SUCCESSFUL))
 746                 return null;
 747
 748             HTTPRetriever htr = (HTTPRetriever) retriever;
 749             if (htr.getResponseCode() == HttpURLConnection.HTTP_NO_CONTENT)
 750             {
 751                 // Mark tile as missing to avoid excessive attempts
 752                 TiledImageLayer.this.levels.markResourceAbsent(tile);
 753                 return null;
 754             }
 755
 756             URLRetriever r = (URLRetriever) retriever;
 757             ByteBuffer buffer = r.getBuffer();
 758
 759             String suffix = null;
 760             for (int i = 0; i < formats.length; i++)
 761             {
 762                 if (htr.getContentType().toLowerCase().contains(formats[i]))
 763                 {
 764                     suffix = suffixes[i];
 765                     break;
 766                 }
 767             }
 768             if (suffix == null)
 769             {
 770                 return null; // TODO: logger error
 771             }
 772
 773             String path = tile.getPath().substring(0, tile.getPath().lastIndexOf("."));
 774             path += suffix;
 775
 776             final File outFile = WorldWind.getDataFileCache().newFile(path);
 777             if (outFile == null)
 778             {
 779                 String msg = Logging.getMessage("generic.CantCreateCacheFile", tile.getPath());
 780                 Logging.logger().severe(msg);
 781                 return null;
 782             }
 783
 784             try
 785             {
 786                 WWIO.saveBuffer(buffer, outFile);
 787                 return buffer;
 788             }
 789             catch (IOException e)
 790             {
 791                 e.printStackTrace(); // TODO: logger error
 792                 return null;
 793             }
 794         }
 795     }
 796 }