gov/nasa/worldwind/layers/RpfLayer.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government as represented by
   3 the Administrator of the National Aeronautics and Space Administration.
   4 All Rights Reserved.
   5 */
   6 package gov.nasa.worldwind.layers;
   7
   8 import com.sun.opengl.util.*;
   9 import com.sun.opengl.util.texture.*;
  10 import gov.nasa.worldwind.*;
  11 import gov.nasa.worldwind.formats.rpf.*;
  12 import gov.nasa.worldwind.geom.*;
  13
  14 import javax.media.opengl.*;
  15 import java.awt.*;
  16 import java.awt.geom.*;
  17 import java.awt.image.*;
  18 import java.io.*;
  19 import java.net.*;
  20 import java.nio.*;
  21 import java.util.*;
  22 import java.util.Queue;
  23 import java.util.concurrent.*;
  24 import java.util.concurrent.locks.*;
  25 import java.util.logging.Level;
  26
  27 /**
  28  * @author dcollins
  29  * @version $Id: RpfLayer.java 2233 2007-07-06 23:56:34Z tgaskins $
  30  */
  31 public class RpfLayer extends AbstractLayer
  32 {
  33     public static final int DefaultWindow = 8;
  34     public static final double DefaultDrawFrameThreshold = 0.75;
  35     public static final double DefaultDrawIconThreshold = 0.25;
  36     public static final long DefaultCacheLoWater = 192L * 1024L * 1024L;
  37     public static final long DefaultCacheHiWater = 256L * 1024L * 1024L;
  38     private static final long FrameExpiryTime = new GregorianCalendar(2007, 5, 31).getTimeInMillis();
  39     private final RpfDataSeries dataSeries;
  40     private int latitudeWindow;
  41     private int longitudeWindow;
  42     private double drawFrameThreshold;
  43     private double drawIconThreshold;
  44
  45     private final MemoryCache memoryCache;
  46     private final String cachePathBase = "Earth/RPF/";
  47
  48     public RpfLayer(RpfDataSeries dataSeries)
  49     {
  50         if (dataSeries == null)
  51         {
  52             String message = WorldWind.retrieveErrMsg("nullValue.RpfDataSeriesIsNull");
  53             WorldWind.logger().log(Level.FINE, message);
  54             throw new IllegalArgumentException(message);
  55         }
  56         this.dataSeries = dataSeries;
  57         this.latitudeWindow = DefaultWindow;
  58         this.longitudeWindow = DefaultWindow;
  59         this.drawFrameThreshold = DefaultDrawFrameThreshold;
  60         this.drawIconThreshold = DefaultDrawIconThreshold;
  61         // Initialize the MemoryCache.
  62         this.memoryCache = new BasicMemoryCache(DefaultCacheLoWater, DefaultCacheHiWater);
  63         this.memoryCache.addCacheListener(new MemoryCache.CacheListener()
  64         {
  65             public void entryRemoved(Object key, Object clientObject)
  66             {
  67                 if (clientObject == null || !(clientObject instanceof RpfTextureTile))
  68                     return;
  69                 RpfTextureTile rpfTextureTile = (RpfTextureTile) clientObject;
  70                 disposalQueue.offer(rpfTextureTile);
  71             }
  72         });
  73     }
  74
  75     public int getLatitudeWindow()
  76     {
  77         return latitudeWindow;
  78     }
  79
  80     public void setLatitudeWindow(int latitudeWindow)
  81     {
  82         this.latitudeWindow = latitudeWindow;
  83     }
  84
  85     public int getLongitudeWindow()
  86     {
  87         return longitudeWindow;
  88     }
  89
  90     public void setLongitudeWindow(int longitudeWindow)
  91     {
  92         this.longitudeWindow = longitudeWindow;
  93     }
  94
  95     public double getDrawFrameThreshold()
  96     {
  97         return drawFrameThreshold;
  98     }
  99
 100     public void setDrawFrameThreshold(double drawFrameThreshold)
 101     {
 102         this.drawFrameThreshold = drawFrameThreshold;
 103     }
 104
 105     public double getDrawIconThreshold()
 106     {
 107         return drawIconThreshold;
 108     }
 109
 110     public void setDrawIconThreshold(double drawIconThreshold)
 111     {
 112         this.drawIconThreshold = drawIconThreshold;
 113     }
 114
 115     public String toString()
 116     {
 117         StringBuilder sb = new StringBuilder();
 118         sb.append(this.dataSeries.seriesCode);
 119         sb.append(": ");
 120         sb.append(this.dataSeries.dataSeries);
 121         return sb.toString();
 122     }
 123
 124     // ============== Frame Directory ======================= //
 125     // ============== Frame Directory ======================= //
 126     // ============== Frame Directory ======================= //
 127
 128     private final Map<FrameKey, FrameRecord> frameDirectory = new HashMap<FrameKey, FrameRecord>();
 129     private Sector sector = Sector.EMPTY_SECTOR;
 130     private int modCount = 0;
 131     private int lastModCount = 0;
 132
 133     private static class FrameKey
 134     {
 135         public final RpfZone zone;
 136         public final int frameNumber;
 137         private final int hashCode;
 138
 139         public FrameKey(RpfZone zone, int frameNumber)
 140         {
 141             this.zone = zone;
 142             this.frameNumber = frameNumber;
 143             this.hashCode = this.computeHash();
 144         }
 145
 146         private int computeHash()
 147         {
 148             int hash = 0;
 149             if (this.zone != null)
 150                 hash = 29 * hash + this.zone.ordinal();
 151             hash = 29 * hash + this.frameNumber;
 152             return hash;
 153         }
 154
 155         public boolean equals(Object o)
 156         {
 157             if (this == o)
 158                 return true;
 159             if (o == null || !o.getClass().equals(this.getClass()))
 160                 return false;
 161             final FrameKey that = (FrameKey) o;
 162             return (this.zone == that.zone) && (this.frameNumber == that.frameNumber);
 163         }
 164
 165         public int hashCode()
 166         {
 167             return this.hashCode;
 168         }
 169     }
 170
 171     private static class FrameRecord
 172     {
 173         private final String filePath;
 174         private RpfFrameProperties properties;
 175         private Sector sector;
 176         private String cacheFilePath;
 177         final Lock fileLock = new ReentrantLock();
 178
 179         public FrameRecord(File file)
 180         {
 181             String fileName = file.getName().toUpperCase();
 182             this.filePath = file.getAbsolutePath();
 183             this.properties = RpfFrameFilenameUtil.parseFilename(fileName);
 184         }
 185
 186         public boolean equals(Object o)
 187         {
 188             if (this == o)
 189                 return true;
 190             if (o == null || !o.getClass().equals(this.getClass()))
 191                 return false;
 192             final FrameRecord that = (FrameRecord) o;
 193             return this.filePath.equals(that.filePath);
 194         }
 195
 196         public String getCacheFilePath(RpfLayer layer)
 197         {
 198             if (this.cacheFilePath == null)
 199             {
 200                 String fileName = RpfFrameFilenameUtil.filenameFor(this.properties);
 201                 this.cacheFilePath = cachePathFor(layer.cachePathBase, fileName, this.properties);
 202             }
 203             return this.cacheFilePath;
 204         }
 205
 206         public long getExpiryTime()
 207         {
 208             return FrameExpiryTime;
 209         }
 210
 211         public String getFilePath()
 212         {
 213             return this.filePath;
 214         }
 215
 216         public RpfFrameProperties getRpfFrameProperties()
 217         {
 218             return this.properties;
 219         }
 220
 221         public Sector getSector()
 222         {
 223             if (this.sector == null)
 224             {
 225                 RpfFrameProperties rpfFrameProperties = this.getRpfFrameProperties();
 226                 this.sector = sectorFor(rpfFrameProperties);
 227             }
 228             return this.sector;
 229         }
 230     }
 231
 232     public int addFrame(File file)
 233     {
 234         if (file == null)
 235         {
 236             String message = WorldWind.retrieveErrMsg("nullValue.FileIsNull");
 237             WorldWind.logger().log(Level.FINE, message);
 238             throw new IllegalArgumentException(message);
 239         }
 240
 241         FrameRecord record = null;
 242         try
 243         {
 244             record = new FrameRecord(file);
 245         }
 246         catch (Exception e)
 247         {
 248             String message = WorldWind.retrieveErrMsg("layers.RpfLayer.ExceptionParsingFileName") + file;
 249             WorldWind.logger().log(Level.FINE, message, e);
 250         }
 251
 252         if (record != null && (this.dataSeries == record.getRpfFrameProperties().dataSeries))
 253         {
 254             this.addRecord(record);
 255             return 1;
 256         }
 257         return 0;
 258     }
 259
 260     private void addRecord(FrameRecord record)
 261     {
 262         FrameKey key = keyFor(record);
 263         this.frameDirectory.put(key, record);
 264         ++this.modCount;
 265     }
 266
 267     private static String cachePathFor(String cachePathBase, String filename, RpfFrameProperties properties)
 268     {
 269         StringBuilder sb = new StringBuilder(cachePathBase);
 270         sb.append(properties.dataSeries.seriesCode).append(File.separatorChar);
 271         sb.append(properties.zone.zoneCode).append(File.separatorChar);
 272         sb.append(filename);
 273         sb.append(".").append(TextureIO.DDS);
 274         return sb.toString();
 275     }
 276
 277     private static FrameKey keyFor(FrameRecord record)
 278     {
 279         return new FrameKey(record.getRpfFrameProperties().zone, record.getRpfFrameProperties().frameNumber);
 280     }
 281
 282     public int removeFrameFile(File file)
 283     {
 284         if (file == null)
 285             return 0;
 286         RpfFrameProperties properties = null;
 287         try
 288         {
 289             properties = RpfFrameFilenameUtil.parseFilename(file.getName().toUpperCase());
 290         }
 291         catch (IllegalArgumentException e)
 292         {
 293             String message = WorldWind.retrieveErrMsg("layers.RpfLayer.ExceptionParsingFileName") + file;
 294             WorldWind.logger().log(Level.FINE, message, e);
 295         }
 296         return removeFrame(properties);
 297     }
 298
 299     private int removeFrame(RpfFrameProperties properties)
 300     {
 301         if (properties == null)
 302             return 0;
 303         if (this.dataSeries == properties.dataSeries)
 304         {
 305             this.removeKey(new FrameKey(properties.zone, properties.frameNumber));
 306             return 1;
 307         }
 308         return 0;
 309     }
 310
 311     private boolean removeKey(FrameKey key)
 312     {
 313         FrameRecord value = this.frameDirectory.remove(key);
 314         --this.modCount;
 315         return value != null;
 316     }
 317
 318     private static Sector sectorFor(RpfFrameProperties properties)
 319     {
 320         if (properties == null
 321             || properties.zone == null
 322             || properties.dataSeries == null)
 323             return null;
 324         RpfZone.ZoneValues zoneValues = properties.zone.zoneValues(properties.dataSeries);
 325         if (properties.frameNumber < 0 || properties.frameNumber > (zoneValues.maximumFrameNumber - 1))
 326             return null;
 327         return zoneValues.frameExtent(properties.frameNumber);
 328     }
 329
 330     private void updateSector()
 331     {
 332         Sector newSector = null;
 333         for (FrameRecord record : this.frameDirectory.values())
 334         {
 335             if (record.getSector() != null)
 336                 newSector = (newSector != null) ? newSector.union(record.getSector()) : record.getSector();
 337         }
 338         this.sector = newSector;
 339     }
 340
 341     // ============== Tile Assembly ======================= //
 342     // ============== Tile Assembly ======================= //
 343     // ============== Tile Assembly ======================= //
 344
 345     private void assembleTiles(DrawContext dc, Map<FrameKey, RpfTextureTile> cachedTiles,
 346         Queue<RpfTextureTile> tilesToRender)
 347     {
 348         synchronized (cachedTiles)
 349         {
 350             for (RpfTextureTile rpfTextureTile : cachedTiles.values())
 351             {
 352                 if (this.isSectorVisible(dc, rpfTextureTile.getSector()))
 353                     tilesToRender.offer(rpfTextureTile);
 354             }
 355         }
 356     }
 357
 358     private void assembleRequests(DrawContext dc, RpfDataSeries dataSeries, Sector viewingSector,
 359         Queue<FrameRecord> framesToRequest)
 360     {
 361         for (RpfZone zone : RpfZone.values())
 362         {
 363             RpfZone.ZoneValues zoneValues = zone.zoneValues(dataSeries);
 364             Sector sector = zoneValues.extent.intersection(viewingSector);
 365             if (sector != null && this.isSectorVisible(dc, sector))
 366                 this.assembleRequestsForZone(dc, zoneValues, sector, framesToRequest);
 367         }
 368     }
 369
 370     private void assembleRequestsForZone(DrawContext dc, RpfZone.ZoneValues zoneValues, Sector sector,
 371         Queue<FrameRecord> framesToRequest)
 372     {
 373         int startRow = zoneValues.frameRowFromLatitude(sector.getMinLatitude());
 374         int endRow = zoneValues.frameRowFromLatitude(sector.getMaxLatitude());
 375         int startCol = zoneValues.frameColumnFromLongitude(sector.getMinLongitude());
 376         int endCol = zoneValues.frameColumnFromLongitude(sector.getMaxLongitude());
 377
 378         for (int row = startRow; row <= endRow; row++)
 379         {
 380             for (int col = startCol; col <= endCol; col++)
 381             {
 382                 int frameNum = zoneValues.frameNumber(row, col);
 383                 FrameKey key = new FrameKey(zoneValues.zone, frameNum);
 384                 RpfTextureTile tile = this.getTile(key);
 385                 if (tile == null)
 386                 {
 387                     FrameRecord record = this.frameDirectory.get(key);
 388                     if (record != null && this.isSectorVisible(dc, record.getSector()))
 389                         framesToRequest.offer(record);
 390                 }
 391             }
 392         }
 393     }
 394
 395     private static Sector[] normalizeSector(Sector sector)
 396     {
 397         Angle minLat = clampAngle(sector.getMinLatitude(), Angle.NEG90, Angle.POS90);
 398         Angle maxLat = clampAngle(sector.getMaxLatitude(), Angle.NEG90, Angle.POS90);
 399         if (maxLat.degrees < minLat.degrees)
 400         {
 401             Angle tmp = minLat;
 402             minLat = maxLat;
 403             maxLat = tmp;
 404         }
 405
 406         Angle minLon = normalizeAngle(sector.getMinLongitude(), Angle.NEG180, Angle.POS180);
 407         Angle maxLon = normalizeAngle(sector.getMaxLongitude(), Angle.NEG180, Angle.POS180);
 408         if (maxLon.degrees < minLon.degrees)
 409         {
 410             return new Sector[] {
 411                 new Sector(minLat, maxLat, minLon, Angle.POS180),
 412                 new Sector(minLat, maxLat, Angle.NEG180, maxLon),
 413             };
 414         }
 415
 416         return new Sector[] {new Sector(minLat, maxLat, minLon, maxLon)};
 417     }
 418
 419     private static Sector createViewSector(RpfDataSeries dataSeries,
 420         Angle centerLat, Angle centerLon, int latWindowFrames, int lonWindowFrames)
 421     {
 422         RpfZone.ZoneValues zoneValues = RpfZone.Zone1.zoneValues(dataSeries);
 423         if (zoneValues == null)
 424             return null;
 425         Angle latWindow = zoneValues.latitudinalFrameExtent.multiply(latWindowFrames);
 426         Angle lonWindow = zoneValues.longitudinalFrameExtent.multiply(lonWindowFrames);
 427         Angle lat_over_2 = latWindow.divide(2.0);
 428         Angle lon_over_2 = lonWindow.divide(2.0);
 429         return new Sector(
 430             centerLat.subtract(lat_over_2), centerLat.add(lat_over_2),
 431             centerLon.subtract(lon_over_2), centerLon.add(lon_over_2));
 432     }
 433
 434     private static Angle clampAngle(Angle angle, Angle min, Angle max)
 435     {
 436         return (angle.degrees < min.degrees) ? min : ((angle.degrees > max.degrees) ? max : angle);
 437     }
 438
 439     private static Angle normalizeAngle(Angle angle, Angle min, Angle max)
 440     {
 441         Angle range = max.subtract(min);
 442         return (angle.degrees < min.degrees) ?
 443             angle.add(range) : ((angle.degrees > max.degrees) ? angle.subtract(range) : angle);
 444     }
 445
 446     // ============== Rendering ======================= //
 447     // ============== Rendering ======================= //
 448     // ============== Rendering ======================= //
 449
 450     // TODO: compute overview image, simple using j2D
 451     // TODO: extrapolate based on small sample
 452
 453     private static class RpfTextureTile extends TextureTile
 454     {
 455         final FrameKey frameKey;
 456         final FrameRecord frameRecord;
 457
 458         RpfTextureTile(FrameKey frameKey, FrameRecord frameRecord)
 459         {
 460             super(frameRecord.getSector());
 461             this.frameKey = frameKey;
 462             this.frameRecord = frameRecord;
 463         }
 464     }
 465
 466     private final BlockingQueue<Disposable> disposalQueue = new LinkedBlockingQueue<Disposable>();
 467     private final IconRenderer iconRenderer = new IconRenderer();
 468     private TextureTile coverageTile;
 469     private WWIcon icon;
 470     private boolean drawCoverage = true;
 471     private boolean drawIcon = true;
 472     private static Boolean haveARBNonPowerOfTwo = null;
 473
 474     private static TextureData createCoverageTextureData(int width, int height,
 475         Sector extent, Collection<FrameRecord> coverage)
 476     {
 477         IntBuffer buffer = BufferUtil.newIntBuffer(width * height);
 478         Angle latWidth = extent.getMaxLatitude().subtract(extent.getMinLatitude());
 479         Angle lonWidth = extent.getMaxLongitude().subtract(extent.getMinLongitude());
 480         for (FrameRecord record : coverage)
 481         {
 482             int x0 = (int) Math.round((width - 1)
 483                 * record.sector.getMinLongitude().subtract(extent.getMinLongitude()).divide(lonWidth));
 484             int x1 = (int) Math.round((width - 1)
 485                 * record.sector.getMaxLongitude().subtract(extent.getMinLongitude()).divide(lonWidth));
 486
 487             int y0 = (int) Math.round((height - 1)
 488                 * record.sector.getMinLatitude().subtract(extent.getMinLatitude()).divide(latWidth));
 489             int y1 = (int) Math.round((height - 1)
 490                 * record.sector.getMaxLatitude().subtract(extent.getMinLatitude()).divide(latWidth));
 491
 492             for (int y = y0; y <= y1; y++)
 493             {
 494                 for (int x = x0; x <= x1; x++)
 495                 {
 496                     buffer.put(x + y * width, 0x4040407F);
 497                 }
 498             }
 499         }
 500         buffer.rewind();
 501         return new TextureData(GL.GL_RGBA, width, height, 0, GL.GL_RGBA, GL.GL_UNSIGNED_INT_8_8_8_8,
 502             false, false, false, buffer, null);
 503     }
 504
 505 //    private static TextureData createCoverageTextureData(int width, int height,
 506 //        Sector extent, Collection<FrameRecord> coverage)
 507 //    {
 508 //        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_4BYTE_ABGR);
 509 //        Graphics2D g2d = image.createGraphics();
 510 //        Color fillColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
 511 //        for (FrameRecord record : coverage)
 512 //            drawFrame(g2d, width, height, fillColor, extent, record);
 513 //
 514 //        TextureData textureData = new TextureData(GL.GL_RGBA, GL.GL_RGBA, false, image);
 515 //        textureData.setMustFlipVertically(false);
 516 //        return textureData;
 517 //    }
 518
 519 //    private static void drawFrame(Graphics2D g2d, int gWidth, int gHeight, Color fillColor,
 520 //        Sector graphicsExtent, FrameRecord record)
 521 //    {
 522 //        Angle xRange = graphicsExtent.getMaxLongitude().subtract(graphicsExtent.getMinLongitude());
 523 //        int x0 = (int) Math.round((gWidth - 1)
 524 //            * record.getSector().getMinLongitude().subtract(graphicsExtent.getMinLongitude()).divide(xRange));
 525 //        int x1 = (int) Math.round((gWidth - 1)
 526 //            * record.getSector().getMaxLongitude().subtract(graphicsExtent.getMinLongitude()).divide(xRange));
 527 //
 528 //        Angle yRange = graphicsExtent.getMaxLatitude().subtract(graphicsExtent.getMinLatitude());
 529 //        int y0 = (int) Math.round((gHeight - 1)
 530 //            * record.getSector().getMinLatitude().subtract(graphicsExtent.getMinLatitude()).divide(yRange));
 531 //        int y1 = (int) Math.round((gHeight - 1)
 532 //            * record.getSector().getMaxLatitude().subtract(graphicsExtent.getMinLatitude()).divide(yRange));
 533 //
 534 //        g2d.setColor(fillColor);
 535 //        g2d.fillRect(x0, y0, x1 - x0, y1 - y0);
 536 //
 537 ////        BufferedImage img = null;
 538 ////        try
 539 ////        {
 540 ////            RpfImageFile rpfImageFile = RpfImageFile.load(new File(record.filePath));
 541 ////            img = rpfImageFile.getBufferedImage();
 542 ////        }
 543 ////        catch (Exception e)
 544 ////        {
 545 ////            WorldWind.logger().log(Level.FINE, "", e);
 546 ////        }
 547 ////        if (img == null)
 548 ////            return;
 549 ////
 550 ////
 551 ////        double sx = (x1 - x0) / (double) img.getWidth();
 552 ////        double sy = (y1 - y0) / (double) img.getHeight();
 553 ////        BufferedImageOp op = new AffineTransformOp(
 554 ////            AffineTransform.getScaleInstance(sx, sy), AffineTransformOp.TYPE_BICUBIC);
 555 ////
 556 ////        g2d.drawImage(img, op, x0, y0);
 557 //    }
 558
 559     public void dispose()
 560     {
 561         // Clear queues.
 562         this.cachedTiles.clear();
 563         this.readQueue.clear();
 564         this.downloadQueue.clear();
 565         // Dispose objects that allocated GL memory.
 566         if (this.iconRenderer != null)
 567             disposalQueue.offer(this.iconRenderer);
 568         if (this.coverageTile != null)
 569         {
 570             disposalQueue.offer(this.coverageTile);
 571             this.coverageTile = null;
 572         }
 573         processDisposables();
 574     }
 575
 576     protected void doRender(DrawContext dc)
 577     {
 578         // Gather GL extension info.
 579         if (haveARBNonPowerOfTwo == null)
 580             haveARBNonPowerOfTwo = dc.getGL().isExtensionAvailable("GL_ARB_texture_non_power_of_two");
 581
 582         // Process disposable queue.
 583         this.processDisposables();
 584
 585         // Update sector and coverage renderables when frame contents change.
 586         if (this.modCount != this.lastModCount)
 587         {
 588             this.updateSector();
 589             this.updateCoverage();
 590             this.lastModCount = this.modCount;
 591         }
 592
 593         if (!this.isSectorVisible(dc, this.sector))
 594             return;
 595
 596         // Create viewing window.
 597         View view = dc.getView();
 598         Sector viewingSector = createViewSector(
 599             this.dataSeries,
 600             view.getLatitude(), view.getLongitude(),
 601             this.latitudeWindow, this.longitudeWindow);
 602
 603         // Assemble frame requests.
 604         Queue<FrameRecord> requestQueue = new LinkedList<FrameRecord>();
 605         for (Sector sector : normalizeSector(viewingSector))
 606         {
 607             this.assembleRequests(dc, this.dataSeries, sector, requestQueue);
 608         }
 609
 610         // Assemble visible, in-memory tiles.
 611         Queue<RpfTextureTile> renderQueue = new LinkedList<RpfTextureTile>();
 612         this.assembleTiles(dc, this.cachedTiles, renderQueue);
 613         // Compute the union of rendred tile sectors.
 614         Sector drawSector = null;
 615         for (RpfTextureTile tile : renderQueue)
 616         {
 617             drawSector = (drawSector != null) ? drawSector.union(tile.getSector()) : tile.getSector();
 618         }
 619
 620         // Render overview.
 621         this.renderCoverage(dc);
 622
 623         // Render frame tiles.
 624         if (percentViewportOfSector(dc, viewingSector) > this.drawFrameThreshold)
 625         {
 626             this.renderFrames(dc, renderQueue);
 627             this.requestAllFrames(requestQueue);
 628         }
 629
 630         // Render icon.
 631         if (percentViewportOfSector(dc, this.sector) < this.drawIconThreshold)
 632         {
 633             this.renderIcon(dc, drawSector);
 634         }
 635
 636         this.sendRequests();
 637     }
 638
 639     public WWIcon getIcon()
 640     {
 641         return this.icon;
 642     }
 643
 644     private static void initializeOverviewTexture(DrawContext dc, Texture texture)
 645     {
 646         texture.setTexParameteri(GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
 647         texture.setTexParameteri(GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
 648         texture.setTexParameteri(GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
 649         texture.setTexParameteri(GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
 650         int[] maxAnisotropy = new int[1];
 651         dc.getGL().glGetIntegerv(GL.GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy, 0);
 652         texture.setTexParameteri(GL.GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy[0]);
 653     }
 654
 655     public boolean isDrawCoverage()
 656     {
 657         return this.drawCoverage;
 658     }
 659
 660     public boolean isDrawIcon()
 661     {
 662         return this.drawIcon;
 663     }
 664
 665     private boolean isSectorVisible(DrawContext dc, Sector sector)
 666     {
 667         if (dc.getVisibleSector() != null && !sector.intersects(dc.getVisibleSector()))
 668             return false;
 669
 670         Extent e = Sector.computeBoundingCylinder(dc.getGlobe(), dc.getVerticalExaggeration(), sector);
 671         return e.intersects(dc.getView().getFrustumInModelCoordinates());
 672     }
 673
 674     private static int pixelSizeOfSector(DrawContext dc, Sector sector)
 675     {
 676         LatLon centroid = sector.getCentroid();
 677         Globe globe = dc.getGlobe();
 678         Vec4 centroidPoint = globe.computePointFromPosition(centroid.getLatitude(), centroid.getLongitude(), 0);
 679         Vec4 minPoint = globe.computePointFromPosition(sector.getMinLatitude(), sector.getMinLongitude(), 0);
 680         Vec4 maxPoint = globe.computePointFromPosition(sector.getMaxLatitude(), sector.getMaxLongitude(), 0);
 681         double distanceToEye = centroidPoint.distanceTo3(dc.getView().getEyePoint());
 682         double sectorSize = minPoint.distanceTo3(maxPoint);
 683         double pixelSize = dc.getView().computePixelSizeAtDistance(distanceToEye);
 684         return (int) Math.round(sectorSize / pixelSize);
 685     }
 686
 687     private static double percentViewportOfSector(DrawContext dc, Sector sector)
 688     {
 689         Rectangle viewport = dc.getView().getViewport();
 690         double pixelSize = pixelSizeOfSector(dc, sector);
 691         double maxDimension = Math.min(viewport.width, viewport.height);
 692         return pixelSize / maxDimension;
 693     }
 694
 695     private void processDisposables()
 696     {
 697         Disposable disposable;
 698         while ((disposable = this.disposalQueue.poll()) != null)
 699         {
 700             if (disposable instanceof RpfTextureTile)
 701                 this.evictTile(((RpfTextureTile) disposable).frameKey);
 702             disposable.dispose();
 703         }
 704     }
 705
 706     private void renderCoverage(DrawContext dc)
 707     {
 708         // Render coverage tile.
 709         if (this.drawCoverage && this.coverageTile != null)
 710         {
 711             GL gl = dc.getGL();
 712             int attribBits = GL.GL_ENABLE_BIT | GL.GL_COLOR_BUFFER_BIT | GL.GL_POLYGON_BIT;
 713             gl.glPushAttrib(attribBits);
 714             try
 715             {
 716                 gl.glEnable(GL.GL_BLEND);
 717                 gl.glEnable(GL.GL_CULL_FACE);
 718                 gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
 719                 gl.glCullFace(GL.GL_BACK);
 720                 gl.glPolygonMode(GL.GL_FRONT, GL.GL_FILL);
 721                 dc.getSurfaceTileRenderer().renderTile(dc, this.coverageTile);
 722             }
 723             finally
 724             {
 725                 gl.glPopAttrib();
 726             }
 727         }
 728     }
 729
 730     private void renderIcon(DrawContext dc, Sector drawSector)
 731     {
 732         // Render coverage icon.
 733         if (this.drawIcon && this.icon != null)
 734         {
 735             LatLon centroid = (drawSector != null) ? drawSector.getCentroid() : this.sector.getCentroid();
 736             this.icon.setPosition(new Position(centroid, 0));
 737             this.iconRenderer.render(dc, this.icon, null);
 738         }
 739     }
 740
 741     private void renderFrames(DrawContext dc, Queue<RpfTextureTile> rpfTextureTiles)
 742     {
 743         GL gl = dc.getGL();
 744         int attribBits = GL.GL_ENABLE_BIT | GL.GL_POLYGON_BIT;
 745         gl.glPushAttrib(attribBits);
 746         try
 747         {
 748             gl.glEnable(GL.GL_CULL_FACE);
 749             gl.glCullFace(GL.GL_BACK);
 750             gl.glPolygonMode(GL.GL_FRONT, GL.GL_FILL);
 751             dc.getSurfaceTileRenderer().renderTiles(dc, rpfTextureTiles);
 752         }
 753         finally
 754         {
 755             gl.glPopAttrib();
 756         }
 757     }
 758
 759     public void setIcon(WWIcon icon)
 760     {
 761         if (icon == null)
 762         {
 763             String message = WorldWind.retrieveErrMsg("nullValue.Icon");
 764             WorldWind.logger().log(Level.FINE, message);
 765             throw new IllegalArgumentException(message);
 766         }
 767         this.icon = icon;
 768     }
 769
 770     public void setDrawCoverage(boolean drawCoverage)
 771     {
 772         this.drawCoverage = drawCoverage;
 773     }
 774
 775     public void setDrawIcon(boolean drawIcon)
 776     {
 777         this.drawIcon = drawIcon;
 778     }
 779
 780     private void updateCoverage()
 781     {
 782         if (this.coverageTile != null)
 783             disposalQueue.offer(this.coverageTile);
 784         TextureData textureData = createCoverageTextureData(1024, 1024, this.sector, this.frameDirectory.values());
 785         this.coverageTile = new TextureTile(this.sector)
 786         {
 787             public void initializeTexture(DrawContext dc)
 788             {
 789                 if (this.getTexture() == null)
 790                 {
 791                     Texture tex = TextureIO.newTexture(this.getTextureData());
 792                     initializeOverviewTexture(dc, tex);
 793                     this.setTexture(tex);
 794                 }
 795             }
 796         };
 797         this.coverageTile.setTextureData(textureData);
 798     }
 799
 800     // ============== Image Reading and Conversion ======================= //
 801     // ============== Image Reading and Conversion ======================= //
 802     // ============== Image Reading and Conversion ======================= //
 803
 804     private final Map<FrameKey, RpfTextureTile> cachedTiles = new HashMap<FrameKey, RpfTextureTile>();
 805     private final LinkedList<FrameRequest> downloadQueue = new LinkedList<FrameRequest>();
 806     private final LinkedList<FrameRequest> readQueue = new LinkedList<FrameRequest>();
 807 //    private final AbsentResourceList absentResourceList = new AbsentResourceList();
 808
 809     private static class FrameRequest
 810     {
 811         static final long STALE_REQUEST_LIMIT = 10000L;
 812         final FrameRecord frameRecord;
 813         long timestamp;
 814
 815         public FrameRequest(FrameRecord frameRecord)
 816         {
 817             this.frameRecord = frameRecord;
 818             this.timestamp = System.currentTimeMillis();
 819         }
 820
 821         public void touch()
 822         {
 823             this.timestamp = System.currentTimeMillis();
 824         }
 825
 826         public boolean isStale()
 827         {
 828             return (System.currentTimeMillis() - this.timestamp) > STALE_REQUEST_LIMIT;
 829         }
 830     }
 831
 832     private static class RpfRetriever extends WWObjectImpl implements Retriever
 833     {
 834         private final RpfLayer layer;
 835         private final FrameRecord record;
 836         private volatile RpfImageFile rpfImageFile;
 837         private volatile ByteBuffer buffer;
 838         private volatile String state = RETRIEVER_STATE_NOT_STARTED;
 839         private long submitTime;
 840         private long beginTime;
 841         private long endTime;
 842         private int connectTimeout = -1;
 843         private int readTimeout = -1;
 844         private int staleRequestLimit = -1;
 845
 846         public RpfRetriever(RpfLayer layer, FrameRecord record)
 847         {
 848             this.layer = layer;
 849             this.record = record;
 850         }
 851
 852         public boolean equals(Object o)
 853         {
 854             if (this == o)
 855                 return true;
 856             if (o == null || !o.getClass().equals(this.getClass()))
 857                 return false;
 858             final RpfRetriever that = (RpfRetriever) o;
 859             return this.record.equals(that.record);
 860         }
 861
 862         public long getBeginTime()
 863         {
 864             return this.beginTime;
 865         }
 866
 867         public ByteBuffer getBuffer()
 868         {
 869             return this.buffer;
 870         }
 871
 872         public int getContentLength()
 873         {
 874             return 0;
 875         }
 876
 877         public int getContentLengthRead()
 878         {
 879             return 0;
 880         }
 881
 882         public String getContentType()
 883         {
 884             return null;
 885         }
 886
 887         public long getEndTime()
 888         {
 889             return this.endTime;
 890         }
 891
 892         public String getName()
 893         {
 894             return this.record.getFilePath();
 895         }
 896
 897         public String getState()
 898         {
 899             return this.state;
 900         }
 901
 902         public long getSubmitTime()
 903         {
 904             return this.submitTime;
 905         }
 906
 907         public int getConnectTimeout()
 908         {
 909             return connectTimeout;
 910         }
 911
 912         public void setConnectTimeout(int connectTimeout)
 913         {
 914             this.connectTimeout = connectTimeout;
 915         }
 916
 917         public int getReadTimeout()
 918         {
 919             return readTimeout;
 920         }
 921
 922         public void setReadTimeout(int readTimeout)
 923         {
 924             this.readTimeout = readTimeout;
 925         }
 926
 927         public int getStaleRequestLimit()
 928         {
 929             return this.staleRequestLimit;
 930         }
 931
 932         public void setStaleRequestLimit(int staleRequestLimit)
 933         {
 934             this.staleRequestLimit = staleRequestLimit;
 935         }
 936
 937         private boolean interrupted()
 938         {
 939             if (Thread.currentThread().isInterrupted())
 940             {
 941                 this.setState(RETRIEVER_STATE_INTERRUPTED);
 942                 String message = WorldWind.retrieveErrMsg("layers.RpfLayer.DownloadInterrupted")
 943                     + this.record.getFilePath();
 944                 WorldWind.logger().log(Level.FINER, message);
 945                 return true;
 946             }
 947             return false;
 948         }
 949
 950         public void setBeginTime(long beginTime)
 951         {
 952             this.beginTime = beginTime;
 953         }
 954
 955         public void setEndTime(long endTime)
 956         {
 957             this.endTime = endTime;
 958         }
 959
 960         private void setState(String state)
 961         {
 962             String oldState = this.state;
 963             this.state = state;
 964             this.firePropertyChange(AVKey.RETRIEVER_STATE, oldState, this.state);
 965         }
 966
 967         public void setSubmitTime(long submitTime)
 968         {
 969             this.submitTime = submitTime;
 970         }
 971
 972         public Retriever call() throws Exception
 973         {
 974             if (this.interrupted())
 975                 return this;
 976
 977             String cacheFilePath = this.record.getCacheFilePath(this.layer);
 978
 979             if (!this.record.fileLock.tryLock())
 980             {
 981                 this.setState(RETRIEVER_STATE_SUCCESSFUL);
 982                 return this;
 983             }
 984             try
 985             {
 986                 this.setState(RETRIEVER_STATE_STARTED);
 987
 988                 if (!this.interrupted())
 989                 {
 990                     if (isFileResident(cacheFilePath))
 991                     {
 992                         this.setState(RETRIEVER_STATE_SUCCESSFUL);
 993                         return this;
 994                     }
 995                 }
 996
 997                 if (!this.interrupted())
 998                 {
 999                     this.setState(RETRIEVER_STATE_CONNECTING);
1000                     File file = new File(this.record.getFilePath());
1001                     if (!file.exists())
1002                     {
1003                         String message = WorldWind.retrieveErrMsg("generic.fileNotFound") + this.record.getFilePath();
1004                         throw new IOException(message);
1005                     }
1006                     this.rpfImageFile = RpfImageFile.load(file);
1007                 }
1008
1009                 if (!this.interrupted())
1010                 {
1011                     this.setState(RETRIEVER_STATE_READING);
1012                     File file = WorldWind.dataFileCache().newFile(cacheFilePath);
1013                     if (file == null)
1014                     {
1015                         String message = WorldWind.retrieveErrMsg("generic.CantCreateCacheFile")
1016                             + cacheFilePath;
1017                         throw new IOException(message);
1018                     }
1019                     if (haveARBNonPowerOfTwo)
1020                     {
1021                         this.buffer = this.rpfImageFile.getImageAsDdsTexture();
1022                     }
1023                     else
1024                     {
1025                         BufferedImage src = this.rpfImageFile.getBufferedImage();
1026                         int dstWidth = previousPowerOfTwo(src.getWidth());
1027                         int dstHeight = previousPowerOfTwo(src.getHeight());
1028                         double sx = dstWidth / (double) src.getWidth();
1029                         double sy = dstHeight / (double) src.getHeight();
1030                         AffineTransformOp op = new AffineTransformOp(
1031                             AffineTransform.getScaleInstance(sx, sy), AffineTransformOp.TYPE_BICUBIC);
1032                         BufferedImage dst = new BufferedImage(dstWidth, dstHeight, src.getType());
1033                         op.filter(src, dst);
1034                         this.buffer = DDSConverter.convertToDxt1NoTransparency(dst);
1035                     }
1036                     WWIO.saveBuffer(this.buffer, file);
1037                 }
1038
1039                 if (!this.interrupted())
1040                 {
1041                     this.setState(RETRIEVER_STATE_SUCCESSFUL);
1042 //                    this.layer.absentResourceList.unmarkResourceAbsent(absentIdFor(this.record));
1043                     this.layer.firePropertyChange(AVKey.LAYER, null, this.layer);
1044                 }
1045             }
1046             catch (Exception e)
1047             {
1048                 this.setState(RETRIEVER_STATE_ERROR);
1049 //                this.layer.absentResourceList.markResourceAbsent(absentIdFor(this.record));
1050                 throw e;
1051             }
1052             finally
1053             {
1054                 this.record.fileLock.unlock();
1055             }
1056
1057             return this;
1058         }
1059     }
1060
1061     private static class ReadTask implements Runnable
1062     {
1063         public final RpfLayer layer;
1064         public final FrameRecord record;
1065
1066         public ReadTask(RpfLayer layer, FrameRecord record)
1067         {
1068             this.layer = layer;
1069             this.record = record;
1070         }
1071
1072         private void deleteCorruptFile(URL fileURL)
1073         {
1074             WorldWind.dataFileCache().removeFile(fileURL);
1075             String message = WorldWind.retrieveErrMsg("generic.DeletedCorruptDataFile") + fileURL;
1076             WorldWind.logger().log(Level.FINER, message);
1077         }
1078
1079 //        private void deleteOutOfDateFile(URL fileURL)
1080 //        {
1081 //            WorldWind.dataFileCache().removeFile(fileURL);
1082 //            String message = WorldWind.retrieveErrMsg("generic.DataFileExpired") + fileURL;
1083 //            WorldWind.logger().log(Level.FINER, message);
1084 //        }
1085
1086         public boolean equals(Object o)
1087         {
1088             if (this == o)
1089                 return true;
1090             if (o == null || !o.getClass().equals(this.getClass()))
1091                 return false;
1092             final ReadTask that = (ReadTask) o;
1093             return (this.record != null) ? this.record.equals(that.record) : (that.record == null);
1094         }
1095
1096         public void run()
1097         {
1098             FrameKey key = keyFor(this.record);
1099             if (!this.layer.isTileResident(key))
1100             {
1101                 this.readFrame(key, this.record);
1102                 this.layer.firePropertyChange(AVKey.LAYER, null, this.layer);
1103             }
1104         }
1105
1106         public void readFrame(FrameKey key, FrameRecord record)
1107         {
1108             String cacheFilePath = record.getCacheFilePath(this.layer);
1109             URL dataFileURL = WorldWind.dataFileCache().findFile(cacheFilePath, false);
1110             // The cached file does not exist. Issue a download and return.
1111             if (dataFileURL == null)
1112             {
1113                 this.layer.downloadFrame(this.record);
1114                 return;
1115             }
1116
1117             if (!record.fileLock.tryLock())
1118                 return;
1119             try
1120             {
1121 //                // The file has expired. Delete it.
1122 //                if (WWIO.isFileOutOfDate(dataFileURL, record.getExpiryTime()))
1123 //                {
1124 //                    this.deleteOutOfDateFile(dataFileURL);
1125 //                    this.layer.firePropertyChange(AVKey.LAYER, null, this.layer);
1126 //                    return;
1127 //                }
1128
1129                 if (this.layer.isTileResident(key))
1130                     return;
1131
1132                 TextureData textureData = null;
1133                 try
1134                 {
1135                     textureData = TextureIO.newTextureData(dataFileURL, false, TextureIO.DDS);
1136                 }
1137                 catch (IOException e)
1138                 {
1139                     String message = WorldWind.retrieveErrMsg("generic.TextureIOException") + cacheFilePath;
1140                     WorldWind.logger().log(Level.FINE, message, e);
1141                 }
1142
1143                 // The file has expired. Delete it.
1144                 if (textureData == null)
1145                 {
1146                     this.deleteCorruptFile(dataFileURL);
1147 //                    this.layer.absentResourceList.markResourceAbsent(absentIdFor(record));
1148                     return;
1149                 }
1150                 else
1151                 {
1152 //                    this.layer.absentResourceList.unmarkResourceAbsent(absentIdFor(record));
1153                 }
1154
1155                 RpfTextureTile rpfTextureTile = new RpfTextureTile(key, record);
1156                 rpfTextureTile.setTextureData(textureData);
1157                 this.layer.makeTileResident(key, rpfTextureTile);
1158                 this.layer.firePropertyChange(AVKey.LAYER, null, this.layer);
1159             }
1160             finally
1161             {
1162                 record.fileLock.unlock();
1163             }
1164         }
1165     }
1166
1167     private void downloadFrame(FrameRecord record)
1168     {
1169 //        if (this.absentResourceList.isResourceAbsent(absentIdFor(record)))
1170 //            return;
1171
1172         synchronized (this.downloadQueue)
1173         {
1174             FrameRequest frameRequest = new FrameRequest(record);
1175             int index = this.downloadQueue.indexOf(frameRequest);
1176             // Frame has not been requested, add it.
1177             if (index < 0)
1178                 this.downloadQueue.addFirst(frameRequest);
1179                 // Frame is already requested, update it's timestamp.
1180             else
1181                 this.downloadQueue.get(index).touch();
1182         }
1183     }
1184
1185     private void evictTile(FrameKey key)
1186     {
1187         synchronized (this.cachedTiles)
1188         {
1189             // Value is assumed to be evicted from memory cache.
1190             this.cachedTiles.remove(key);
1191         }
1192     }
1193
1194     private RpfTextureTile getTile(FrameKey key)
1195     {
1196         synchronized (this.cachedTiles)
1197         {
1198             // Touch the value in memory cache.
1199             this.memoryCache.getObject(key);
1200             // Return the value in our local cache directory.
1201             return this.cachedTiles.get(key);
1202         }
1203     }
1204
1205 //    private static long absentIdFor(FrameRecord record)
1206 //    {
1207 //        RpfFrameProperties properties = record.getRpfFrameProperties();
1208 //        return properties.zone.ordinal() + (100 * properties.frameNumber);
1209 //    }
1210
1211     private static boolean isFileResident(String fileName)
1212     {
1213         return WorldWind.dataFileCache().findFile(fileName, false) != null;
1214     }
1215
1216     private boolean isTileResident(FrameKey key)
1217     {
1218         synchronized (this.cachedTiles)
1219         {
1220             // Value may be evicted from memory cache, but still in local cache directory
1221             // (not yet processsed for disposal).
1222             return this.cachedTiles.get(key) != null;
1223         }
1224     }
1225
1226     private void makeTileResident(FrameKey key, RpfTextureTile tile)
1227     {
1228         synchronized (this.memoryCache)
1229         {
1230             this.memoryCache.add(key, tile);
1231         }
1232
1233         synchronized (this.cachedTiles)
1234         {
1235             this.cachedTiles.put(key, tile);
1236         }
1237     }
1238
1239     private static int previousPowerOfTwo(int value)
1240     {
1241         int result = 1;
1242         while (result < value)
1243         {
1244             result <<= 1;
1245         }
1246         return (result >> 1);
1247     }
1248
1249     private void requestFrame(FrameRecord record)
1250     {
1251 //        if (this.absentResourceList.isResourceAbsent(absentIdFor(record)))
1252 //            return;
1253
1254         synchronized (this.readQueue)
1255         {
1256             FrameRequest frameRequest = new FrameRequest(record);
1257             int index = this.readQueue.indexOf(frameRequest);
1258             // Frame has not been requested, add it.
1259             if (index < 0)
1260                 this.readQueue.addFirst(frameRequest);
1261                 // Frame is already requested, update it's timestamp.
1262             else
1263                 this.readQueue.get(index).touch();
1264         }
1265     }
1266
1267     private void requestAllFrames(Collection<FrameRecord> frameRecords)
1268     {
1269         for (FrameRecord record : frameRecords)
1270         {
1271             this.requestFrame(record);
1272         }
1273     }
1274
1275     private void sendRequests()
1276     {
1277         synchronized (this.readQueue)
1278         {
1279             FrameRequest request;
1280             while (!WorldWind.threadedTaskService().isFull() && (request = this.readQueue.poll()) != null)
1281             {
1282                 if (!request.isStale())
1283                     WorldWind.threadedTaskService().addTask(new ReadTask(this, request.frameRecord));
1284             }
1285         }
1286
1287         synchronized (this.downloadQueue)
1288         {
1289             FrameRequest request;
1290             while (!WorldWind.retrievalService().isFull() && (request = this.downloadQueue.poll()) != null)
1291             {
1292                 if (!request.isStale())
1293                     WorldWind.retrievalService().runRetriever(new RpfRetriever(this, request.frameRecord));
1294             }
1295         }
1296     }
1297 }