gov/nasa/worldwind/layers/placename/PlaceNameLayer.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.placename;
   7
   8 import com.sun.opengl.util.BufferUtil;
   9 import gov.nasa.worldwind.*;
  10 import gov.nasa.worldwind.avlist.AVKey;
  11 import gov.nasa.worldwind.cache.*;
  12 import gov.nasa.worldwind.geom.*;
  13 import gov.nasa.worldwind.layers.AbstractLayer;
  14 import gov.nasa.worldwind.pick.PlaceName;
  15 import gov.nasa.worldwind.render.*;
  16 import gov.nasa.worldwind.retrieve.*;
  17 import gov.nasa.worldwind.util.*;
  18 import gov.nasa.worldwind.view.View;
  19
  20 import java.awt.*;
  21 import java.util.*;
  22 import java.util.List;
  23 import java.util.Queue;
  24 import java.util.concurrent.LinkedBlockingQueue;
  25 import java.util.logging.Level;
  26
  27 /**
  28  * @author Paul Collins
  29  * @version $Id: PlaceNameLayer.java 2980 2007-09-22 01:07:06Z tgaskins $
  30  */
  31 public class PlaceNameLayer extends AbstractLayer
  32 {
  33     private final PlaceNameServiceSet placeNameServiceSet;
  34     private final List<Tile[]> tiles = new ArrayList<Tile[]>();
  35     private final MemoryCache memoryCache;
  36
  37     /**
  38      * @param placeNameServiceSet the set of PlaceNameService objects that PlaceNameLayer will render.
  39      * @throws IllegalArgumentException if <code>placeNameServiceSet</code> is null
  40      */
  41     public PlaceNameLayer(PlaceNameServiceSet placeNameServiceSet)
  42     {
  43         if (placeNameServiceSet == null)
  44         {
  45             String message = Logging.getMessage("nullValue.PlaceNameServiceSetIsNull");
  46             Logging.logger().fine(message);
  47             throw new IllegalArgumentException(message);
  48         }
  49
  50         String cacheName = Tile.class.getName();
  51         if (WorldWind.getMemoryCacheSet().containsCache(cacheName))
  52         {
  53             this.memoryCache = WorldWind.getMemoryCache(cacheName);
  54         }
  55         else
  56         {
  57             long size = Configuration.getLongValue(AVKey.PLACENAME_LAYER_CACHE_SIZE, 2000000L);
  58             this.memoryCache = new BasicMemoryCache((long) (0.85 * size), size);
  59             this.memoryCache.setName("Placenames");
  60             WorldWind.getMemoryCacheSet().addCache(cacheName, this.memoryCache);
  61         }
  62
  63         this.placeNameServiceSet = placeNameServiceSet.deepCopy();
  64         for (int i = 0; i < this.placeNameServiceSet.getServiceCount(); i++)
  65         {
  66             tiles.add(i, buildTiles(this.placeNameServiceSet.getService(i)));
  67         }
  68     }
  69
  70     public final PlaceNameServiceSet getPlaceNameServiceSet()
  71     {
  72         return this.placeNameServiceSet;
  73     }
  74
  75     // ============== Tile Assembly ======================= //
  76     // ============== Tile Assembly ======================= //
  77     // ============== Tile Assembly ======================= //
  78
  79     private static class Tile
  80     {
  81         final PlaceNameService placeNameService;
  82         final Sector sector;
  83         final int row;
  84         final int column;
  85         final int hash;
  86         // Computed data.
  87         String fileCachePath = null;
  88         Extent extent = null;
  89         double extentVerticalExaggeration = Double.MIN_VALUE;
  90
  91         static int computeRow(Angle delta, Angle latitude)
  92         {
  93             if (delta == null || latitude == null)
  94             {
  95                 String msg = Logging.getMessage("nullValue.AngleIsNull");
  96                 Logging.logger().severe(msg);
  97                 throw new IllegalArgumentException(msg);
  98             }
  99             return (int) ((latitude.getDegrees() + 90d) / delta.getDegrees());
 100         }
 101
 102         static int computeColumn(Angle delta, Angle longitude)
 103         {
 104             if (delta == null || longitude == null)
 105             {
 106                 String msg = Logging.getMessage("nullValue.AngleIsNull");
 107                 Logging.logger().severe(msg);
 108                 throw new IllegalArgumentException(msg);
 109             }
 110             return (int) ((longitude.getDegrees() + 180d) / delta.getDegrees());
 111         }
 112
 113         static Angle computeRowLatitude(int row, Angle delta)
 114         {
 115             if (delta == null)
 116             {
 117                 String msg = Logging.getMessage("nullValue.AngleIsNull");
 118                 Logging.logger().severe(msg);
 119                 throw new IllegalArgumentException(msg);
 120             }
 121             return Angle.fromDegrees(-90d + delta.getDegrees() * row);
 122         }
 123
 124         static Angle computeColumnLongitude(int column, Angle delta)
 125         {
 126             if (delta == null)
 127             {
 128                 String msg = Logging.getMessage("nullValue.AngleIsNull");
 129                 Logging.logger().severe(msg);
 130                 throw new IllegalArgumentException(msg);
 131             }
 132             return Angle.fromDegrees(-180 + delta.getDegrees() * column);
 133         }
 134
 135         Tile(PlaceNameService placeNameService, Sector sector, int row, int column)
 136         {
 137             this.placeNameService = placeNameService;
 138             this.sector = sector;
 139             this.row = row;
 140             this.column = column;
 141             this.hash = this.computeHash();
 142         }
 143
 144         int computeHash()
 145         {
 146             return this.getFileCachePath() != null ? this.getFileCachePath().hashCode() : 0;
 147         }
 148
 149         @Override
 150         public boolean equals(Object o)
 151         {
 152             if (this == o)
 153                 return true;
 154             if (o == null || this.getClass() != o.getClass())
 155                 return false;
 156
 157             final Tile other = (Tile) o;
 158
 159             return this.getFileCachePath() != null ? !this.getFileCachePath().equals(other.getFileCachePath()) :
 160                 other.getFileCachePath() != null;
 161         }
 162
 163         Extent getExtent(DrawContext dc)
 164         {
 165             if (dc == null)
 166             {
 167                 String message = Logging.getMessage("nullValue.DrawContextIsNull");
 168                 Logging.logger().fine(message);
 169                 throw new IllegalArgumentException(message);
 170             }
 171
 172             if (this.extent == null || this.extentVerticalExaggeration != dc.getVerticalExaggeration())
 173             {
 174                 this.extentVerticalExaggeration = dc.getVerticalExaggeration();
 175                 this.extent = Sector.computeBoundingCylinder(dc.getGlobe(), this.extentVerticalExaggeration,
 176                     this.sector);
 177             }
 178
 179             return extent;
 180         }
 181
 182         String getFileCachePath()
 183         {
 184             if (this.fileCachePath == null)
 185                 this.fileCachePath = this.placeNameService.createFileCachePathFromTile(this.row, this.column);
 186
 187             return this.fileCachePath;
 188         }
 189
 190         PlaceNameService getPlaceNameService()
 191         {
 192             return placeNameService;
 193         }
 194
 195         java.net.URL getRequestURL() throws java.net.MalformedURLException
 196         {
 197             return this.placeNameService.createServiceURLFromSector(this.sector);
 198         }
 199
 200         Sector getSector()
 201         {
 202             return sector;
 203         }
 204
 205         public int hashCode()
 206         {
 207             return this.hash;
 208         }
 209     }
 210
 211     private Tile[] buildTiles(PlaceNameService placeNameService)
 212     {
 213         final Sector sector = placeNameService.getSector();
 214         final Angle dLat = placeNameService.getTileDelta().getLatitude();
 215         final Angle dLon = placeNameService.getTileDelta().getLongitude();
 216
 217         // Determine the row and column offset from the global tiling origin for the southwest tile corner
 218         int firstRow = Tile.computeRow(dLat, sector.getMinLatitude());
 219         int firstCol = Tile.computeColumn(dLon, sector.getMinLongitude());
 220         int lastRow = Tile.computeRow(dLat, sector.getMaxLatitude().subtract(dLat));
 221         int lastCol = Tile.computeColumn(dLon, sector.getMaxLongitude().subtract(dLon));
 222
 223         int nLatTiles = lastRow - firstRow + 1;
 224         int nLonTiles = lastCol - firstCol + 1;
 225
 226         Tile[] tiles = new Tile[nLatTiles * nLonTiles];
 227
 228         Angle p1 = Tile.computeRowLatitude(firstRow, dLat);
 229         for (int row = firstRow; row <= lastRow; row++)
 230         {
 231             Angle p2;
 232             p2 = p1.add(dLat);
 233
 234             Angle t1 = Tile.computeColumnLongitude(firstCol, dLon);
 235             for (int col = firstCol; col <= lastCol; col++)
 236             {
 237                 Angle t2;
 238                 t2 = t1.add(dLon);
 239
 240                 tiles[col + row * nLonTiles] = new Tile(placeNameService, new Sector(p1, p2, t1, t2), row, col);
 241                 t1 = t2;
 242             }
 243             p1 = p2;
 244         }
 245
 246         return tiles;
 247     }
 248
 249     // ============== Place Name Data Structures ======================= //
 250     // ============== Place Name Data Structures ======================= //
 251     // ============== Place Name Data Structures ======================= //
 252
 253     private static class PlaceNameChunk implements Cacheable
 254     {
 255         final PlaceNameService placeNameService;
 256         final StringBuilder textArray;
 257         final int[] textIndexArray;
 258         final double[] latlonArray;
 259         final int numEntries;
 260         final long estimatedMemorySize;
 261
 262         PlaceNameChunk(PlaceNameService service, StringBuilder text, int[] textIndices,
 263             double[] positions, int numEntries)
 264         {
 265             this.placeNameService = service;
 266             this.textArray = text;
 267             this.textIndexArray = textIndices;
 268             this.latlonArray = positions;
 269             this.numEntries = numEntries;
 270             this.estimatedMemorySize = this.computeEstimatedMemorySize();
 271         }
 272
 273         long computeEstimatedMemorySize()
 274         {
 275             long result = 0;
 276             result += BufferUtil.SIZEOF_SHORT * textArray.capacity();
 277             result += BufferUtil.SIZEOF_INT * textIndexArray.length;
 278             result += BufferUtil.SIZEOF_DOUBLE * latlonArray.length;
 279             return result;
 280         }
 281
 282         Position getPosition(int index)
 283         {
 284             int latlonIndex = 2 * index;
 285             return Position.fromDegrees(latlonArray[latlonIndex], latlonArray[latlonIndex + 1], 0);
 286         }
 287
 288         PlaceNameService getPlaceNameService()
 289         {
 290             return this.placeNameService;
 291         }
 292
 293         String getText(int index)
 294         {
 295             int beginIndex = textIndexArray[index];
 296             int endIndex = (index + 1 < numEntries) ? textIndexArray[index + 1] : textArray.length();
 297             return this.textArray.substring(beginIndex, endIndex);
 298         }
 299
 300         public long getSizeInBytes()
 301         {
 302             return this.estimatedMemorySize;
 303         }
 304
 305         Iterator<PlaceName> createRenderIterator(final DrawContext dc)
 306         {
 307             return new Iterator<PlaceName>()
 308             {
 309                 PlaceNameImpl placeNameProxy = new PlaceNameImpl();
 310                 int index = -1;
 311
 312                 public boolean hasNext()
 313                 {
 314                     return index < (PlaceNameChunk.this.numEntries - 1);
 315                 }
 316
 317                 public PlaceName next()
 318                 {
 319                     if (!hasNext())
 320                         throw new NoSuchElementException();
 321                     this.updateProxy(placeNameProxy, ++index);
 322                     return placeNameProxy;
 323                 }
 324
 325                 public void remove()
 326                 {
 327                     throw new UnsupportedOperationException();
 328                 }
 329
 330                 void updateProxy(PlaceNameImpl proxy, int index)
 331                 {
 332                     proxy.text = getText(index);
 333                     proxy.position = getPosition(index);
 334                     proxy.font = placeNameService.getFont();
 335                     proxy.color = placeNameService.getColor();
 336                     proxy.visible = isNameVisible(dc, placeNameService, proxy.position);
 337                 }
 338             };
 339         }
 340     }
 341
 342     private static class PlaceNameImpl implements PlaceName
 343     {
 344         String text;
 345         Position position;
 346         Font font;
 347         Color color;
 348         boolean visible;
 349
 350         PlaceNameImpl()
 351         {
 352         }
 353
 354         public String getText()
 355         {
 356             return this.text;
 357         }
 358
 359         public void setText(String text)
 360         {
 361             throw new UnsupportedOperationException();
 362         }
 363
 364         public Position getPosition()
 365         {
 366             return this.position;
 367         }
 368
 369         public void setPosition(Position position)
 370         {
 371             throw new UnsupportedOperationException();
 372         }
 373
 374         public Font getFont()
 375         {
 376             return this.font;
 377         }
 378
 379         public void setFont(Font font)
 380         {
 381             throw new UnsupportedOperationException();
 382         }
 383
 384         public Color getColor()
 385         {
 386             return this.color;
 387         }
 388
 389         public void setColor(Color color)
 390         {
 391             throw new UnsupportedOperationException();
 392         }
 393
 394         public boolean isVisible()
 395         {
 396             return this.visible;
 397         }
 398
 399         public void setVisible(boolean visible)
 400         {
 401             throw new UnsupportedOperationException();
 402         }
 403
 404         public WWIcon getIcon()
 405         {
 406             return null;
 407         }
 408
 409         public void setIcon(WWIcon icon)
 410         {
 411             throw new UnsupportedOperationException();
 412         }
 413     }
 414
 415     // ============== Rendering ======================= //
 416     // ============== Rendering ======================= //
 417     // ============== Rendering ======================= //
 418
 419     private final PlaceNameRenderer placeNameRenderer = new PlaceNameRenderer();
 420
 421     @Override
 422     public void dispose() // override if disposal is a supported operation
 423     {
 424         super.dispose();
 425
 426         if (this.placeNameRenderer != null)
 427             this.placeNameRenderer.dispose();
 428     }
 429
 430     @Override
 431     protected void doRender(DrawContext dc)
 432     {
 433         boolean enableDepthTest = this.isEnableDepthTest(dc);
 434
 435         int serviceCount = this.placeNameServiceSet.getServiceCount();
 436         for (int i = 0; i < serviceCount; i++)
 437         {
 438             PlaceNameService placeNameService = this.placeNameServiceSet.getService(i);
 439             if (!isServiceVisible(dc, placeNameService))
 440                 continue;
 441
 442             double minDist = placeNameService.getMinDisplayDistance();
 443             double maxDist = placeNameService.getMaxDisplayDistance();
 444             double minDistSquared = minDist * minDist;
 445             double maxDistSquared = maxDist * maxDist;
 446
 447             Tile[] tiles = this.tiles.get(i);
 448             for (Tile tile : tiles)
 449             {
 450                 try
 451                 {
 452                     drawOrRequestTile(dc, tile, minDistSquared, maxDistSquared, enableDepthTest);
 453                 }
 454                 catch (Exception e)
 455                 {
 456                     Logging.logger().log(Level.FINE, Logging.getMessage("layers.PlaceNameLayer.ExceptionRenderingTile"),
 457                         e);
 458                 }
 459             }
 460         }
 461
 462         this.sendRequests();
 463     }
 464
 465     private boolean isEnableDepthTest(DrawContext dc)
 466     {
 467         Position eyePos = dc.getView().getEyePosition();
 468         if (eyePos == null)
 469             return false;
 470
 471         double altitude = eyePos.getElevation();
 472         return altitude < (dc.getVerticalExaggeration() * dc.getGlobe().getMaxElevation());
 473     }
 474
 475     private void drawOrRequestTile(DrawContext dc, Tile tile, double minDisplayDistanceSquared,
 476         double maxDisplayDistanceSquared, boolean enableDepthTest)
 477     {
 478         if (!isTileVisible(dc, tile, minDisplayDistanceSquared, maxDisplayDistanceSquared))
 479             return;
 480
 481         Object cacheObj = this.memoryCache.getObject(tile);
 482         if (cacheObj == null)
 483         {
 484             this.requestTile(this.readQueue, tile);
 485             return;
 486         }
 487
 488         if (!(cacheObj instanceof PlaceNameChunk))
 489             return;
 490
 491         PlaceNameChunk placeNameChunk = (PlaceNameChunk) cacheObj;
 492         Iterator<PlaceName> renderIter = placeNameChunk.createRenderIterator(dc);
 493         placeNameRenderer.render(dc, renderIter, enableDepthTest);
 494     }
 495
 496     private static boolean isServiceVisible(DrawContext dc, PlaceNameService placeNameService)
 497     {
 498         if (!placeNameService.isEnabled())
 499             return false;
 500         //noinspection SimplifiableIfStatement
 501         if (dc.getVisibleSector() != null && !placeNameService.getSector().intersects(dc.getVisibleSector()))
 502             return false;
 503
 504         return placeNameService.getExtent(dc).intersects(dc.getView().getFrustumInModelCoordinates());
 505     }
 506
 507     private static boolean isTileVisible(DrawContext dc, Tile tile, double minDistanceSquared,
 508         double maxDistanceSquared)
 509     {
 510         if (!tile.getSector().intersects(dc.getVisibleSector()))
 511             return false;
 512
 513         View view = dc.getView();
 514         Position eyePos = view.getEyePosition();
 515         if (eyePos == null)
 516             return false;
 517
 518         Angle lat = clampAngle(eyePos.getLatitude(), tile.getSector().getMinLatitude(),
 519             tile.getSector().getMaxLatitude());
 520         Angle lon = clampAngle(eyePos.getLongitude(), tile.getSector().getMinLongitude(),
 521             tile.getSector().getMaxLongitude());
 522         Vec4 p = dc.getGlobe().computePointFromPosition(lat, lon, 0d);
 523         double distSquared = dc.getView().getEyePoint().distanceToSquared3(p);
 524         //noinspection RedundantIfStatement
 525         if (minDistanceSquared > distSquared || maxDistanceSquared < distSquared)
 526             return false;
 527
 528         return true;
 529     }
 530
 531     private static boolean isNameVisible(DrawContext dc, PlaceNameService service, Position namePosition)
 532     {
 533         double elevation = dc.getVerticalExaggeration() * namePosition.getElevation();
 534         Vec4 namePoint = dc.getGlobe().computePointFromPosition(namePosition.getLatitude(),
 535             namePosition.getLongitude(), elevation);
 536         Vec4 eyeVec = dc.getView().getEyePoint();
 537
 538         double dist = eyeVec.distanceTo3(namePoint);
 539         return dist >= service.getMinDisplayDistance() && dist <= service.getMaxDisplayDistance();
 540     }
 541
 542     private static Angle clampAngle(Angle a, Angle min, Angle max)
 543     {
 544         return a.compareTo(min) < 0 ? min : (a.compareTo(max) > 0 ? max : a);
 545     }
 546
 547     // ============== Image Reading and Downloading ======================= //
 548     // ============== Image Reading and Downloading ======================= //
 549     // ============== Image Reading and Downloading ======================= //
 550
 551     private static final int MAX_REQUESTS = 64;
 552     private final Queue<Tile> downloadQueue = new LinkedBlockingQueue<Tile>(MAX_REQUESTS);
 553     private final Queue<Tile> readQueue = new LinkedBlockingQueue<Tile>(MAX_REQUESTS);
 554
 555     private static class RequestTask implements Runnable
 556     {
 557         final PlaceNameLayer layer;
 558         final Tile tile;
 559
 560         RequestTask(PlaceNameLayer layer, Tile tile)
 561         {
 562             this.layer = layer;
 563             this.tile = tile;
 564         }
 565
 566         @Override
 567         public boolean equals(Object o)
 568         {
 569             if (this == o)
 570                 return true;
 571             if (o == null || this.getClass() != o.getClass())
 572                 return false;
 573
 574             final RequestTask other = (RequestTask) o;
 575
 576             // Don't include layer in comparison so that requests are shared among layers
 577             return !(this.tile != null ? !this.tile.equals(other.tile) : other.tile != null);
 578         }
 579
 580         @Override
 581         public int hashCode()
 582         {
 583             return (this.tile != null ? this.tile.hashCode() : 0);
 584         }
 585
 586         public void run()
 587         {
 588             synchronized (tile)
 589             {
 590                 if (this.layer.memoryCache.getObject(this.tile) != null)
 591                     return;
 592
 593                 final java.net.URL tileURL = WorldWind.getDataFileCache().findFile(tile.getFileCachePath(), false);
 594                 if (tileURL != null)
 595                 {
 596                     if (this.layer.loadTile(this.tile, tileURL))
 597                     {
 598                         tile.getPlaceNameService().unmarkResourceAbsent(tile.getPlaceNameService().getTileNumber(
 599                             tile.row,
 600                             tile.column));
 601                         this.layer.firePropertyChange(AVKey.LAYER, null, this);
 602                     }
 603                     else
 604                     {
 605                         // Assume that something's wrong with the file and delete it.
 606                         WorldWind.getDataFileCache().removeFile(tileURL);
 607                         tile.getPlaceNameService().markResourceAbsent(tile.getPlaceNameService().getTileNumber(tile.row,
 608                             tile.column));
 609                         String message = Logging.getMessage("generic.DeletedCorruptDataFile", tileURL);
 610                         Logging.logger().fine(message);
 611                     }
 612                     return;
 613                 }
 614             }
 615
 616             this.layer.requestTile(this.layer.downloadQueue, this.tile);
 617         }
 618
 619         public String toString()
 620         {
 621             return this.tile.toString();
 622         }
 623     }
 624
 625     private static class DownloadPostProcessor implements RetrievalPostProcessor
 626     {
 627         final PlaceNameLayer layer;
 628         final Tile tile;
 629
 630         private DownloadPostProcessor(PlaceNameLayer layer, Tile tile)
 631         {
 632             this.layer = layer;
 633             this.tile = tile;
 634         }
 635
 636         public java.nio.ByteBuffer run(Retriever retriever)
 637         {
 638             if (retriever == null)
 639             {
 640                 String msg = Logging.getMessage("nullValue.RetrieverIsNull");
 641                 Logging.logger().fine(msg);
 642                 throw new IllegalArgumentException(msg);
 643             }
 644
 645             if (!retriever.getState().equals(Retriever.RETRIEVER_STATE_SUCCESSFUL))
 646                 return null;
 647
 648             if (!(retriever instanceof URLRetriever))
 649                 return null;
 650
 651             try
 652             {
 653                 if (retriever instanceof HTTPRetriever)
 654                 {
 655                     HTTPRetriever httpRetriever = (HTTPRetriever) retriever;
 656                     if (httpRetriever.getResponseCode() == java.net.HttpURLConnection.HTTP_NO_CONTENT)
 657                     {
 658                         // Mark tile as missing to avoid further attempts
 659                         tile.getPlaceNameService().markResourceAbsent(tile.getPlaceNameService().getTileNumber(tile.row,
 660                             tile.column));
 661                         return null;
 662                     }
 663                 }
 664
 665                 URLRetriever urlRetriever = (URLRetriever) retriever;
 666                 java.nio.ByteBuffer buffer = urlRetriever.getBuffer();
 667
 668                 synchronized (tile)
 669                 {
 670                     final java.io.File cacheFile = WorldWind.getDataFileCache().newFile(this.tile.getFileCachePath());
 671                     if (cacheFile == null)
 672                     {
 673                         String msg = Logging.getMessage("generic.CantCreateCacheFile", this.tile.getFileCachePath());
 674                         Logging.logger().fine(msg);
 675                         return null;
 676                     }
 677
 678                     if (cacheFile.exists())
 679                         return buffer; // info is already here; don't need to do anything
 680
 681                     if (buffer != null)
 682                     {
 683                         WWIO.saveBuffer(buffer, cacheFile);
 684                         this.layer.firePropertyChange(AVKey.LAYER, null, this);
 685                         return buffer;
 686                     }
 687                 }
 688             }
 689             catch (java.io.IOException e)
 690             {
 691                 Logging.logger().log(Level.FINE, Logging.getMessage(
 692                     "layers.PlaceNameLayer.ExceptionSavingRetrievedFile", this.tile.getFileCachePath()), e);
 693             }
 694
 695             return null;
 696         }
 697     }
 698
 699     private static class GMLPlaceNameSAXHandler extends org.xml.sax.helpers.DefaultHandler
 700     {
 701         static final String GML_FEATURE_MEMBER = "gml:featureMember";
 702         static final String TOPP_FULL_NAME_ND = "topp:full_name_nd";
 703         static final String TOPP_LATITUDE = "topp:latitude";
 704         static final String TOPP_LONGITUDE = "topp:longitude";
 705         final LinkedList<String> internedQNameStack = new LinkedList<String>();
 706         boolean inBeginEndPair = false;
 707         StringBuilder latBuffer = new StringBuilder();
 708         StringBuilder lonBuffer = new StringBuilder();
 709
 710         StringBuilder textArray = new StringBuilder();
 711         int[] textIndexArray = new int[16];
 712         double[] latlonArray = new double[16];
 713         int numEntries = 0;
 714
 715         GMLPlaceNameSAXHandler()
 716         {
 717         }
 718
 719         PlaceNameChunk createPlaceNameChunk(PlaceNameService service)
 720         {
 721             return new PlaceNameChunk(service, this.textArray, this.textIndexArray, this.latlonArray, this.numEntries);
 722         }
 723
 724         void beginEntry()
 725         {
 726             int textIndex = this.textArray.length();
 727             this.textIndexArray = append(this.textIndexArray, this.numEntries, textIndex);
 728             this.inBeginEndPair = true;
 729         }
 730
 731         void endEntry()
 732         {
 733             double lat = this.parseDouble(this.latBuffer);
 734             double lon = this.parseDouble(this.lonBuffer);
 735             int numLatLon = 2 * this.numEntries;
 736             this.latlonArray = this.append(this.latlonArray, numLatLon, lat);
 737             numLatLon++;
 738             this.latlonArray = this.append(this.latlonArray, numLatLon, lon);
 739
 740             this.latBuffer.delete(0, this.latBuffer.length());
 741             this.lonBuffer.delete(0, this.lonBuffer.length());
 742             this.inBeginEndPair = false;
 743             this.numEntries++;
 744         }
 745
 746         double parseDouble(StringBuilder sb)
 747         {
 748             double value = 0;
 749             try
 750             {
 751                 value = Double.parseDouble(sb.toString());
 752             }
 753             catch (NumberFormatException e)
 754             {
 755                 Logging.logger().log(Level.FINE,
 756                     Logging.getMessage("layers.PlaceNameLayer.ExceptionAttemptingToReadFile", ""), e);
 757             }
 758             return value;
 759         }
 760
 761         int[] append(int[] array, int index, int value)
 762         {
 763             if (index >= array.length)
 764                 array = this.resizeArray(array);
 765             array[index] = value;
 766             return array;
 767         }
 768
 769         int[] resizeArray(int[] oldArray)
 770         {
 771             int newSize = 2 * oldArray.length;
 772             int[] newArray = new int[newSize];
 773             System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
 774             return newArray;
 775         }
 776
 777         double[] append(double[] array, int index, double value)
 778         {
 779             if (index >= array.length)
 780                 array = this.resizeArray(array);
 781             array[index] = value;
 782             return array;
 783         }
 784
 785         double[] resizeArray(double[] oldArray)
 786         {
 787             int newSize = 2 * oldArray.length;
 788             double[] newArray = new double[newSize];
 789             System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
 790             return newArray;
 791         }
 792
 793         public void characters(char ch[], int start, int length)
 794         {
 795             if (!this.inBeginEndPair)
 796                 return;
 797
 798             // Top of QName stack is an interned string,
 799             // so we can use pointer comparison.
 800             String internedTopQName = this.internedQNameStack.getFirst();
 801
 802             StringBuilder sb = null;
 803             if (TOPP_LATITUDE == internedTopQName)
 804                 sb = this.latBuffer;
 805             else if (TOPP_LONGITUDE == internedTopQName)
 806                 sb = this.lonBuffer;
 807             else if (TOPP_FULL_NAME_ND == internedTopQName)
 808                 sb = this.textArray;
 809
 810             if (sb != null)
 811                 sb.append(ch, start, length);
 812         }
 813
 814         public void startElement(String uri, String localName, String qName, org.xml.sax.Attributes attributes)
 815         {
 816             // Don't validate uri, localName or attributes because they aren't used.
 817             // Intern the qName string so we can use pointer comparison.
 818             String internedQName = qName.intern();
 819             if (GML_FEATURE_MEMBER == internedQName)
 820                 this.beginEntry();
 821             this.internedQNameStack.addFirst(internedQName);
 822         }
 823
 824         public void endElement(String uri, String localName, String qName)
 825         {
 826             // Don't validate uri or localName because they aren't used.
 827             // Intern the qName string so we can use pointer comparison.
 828             String internedQName = qName.intern();
 829             if (GML_FEATURE_MEMBER == internedQName)
 830                 this.endEntry();
 831             this.internedQNameStack.removeFirst();
 832         }
 833     }
 834
 835     private boolean loadTile(Tile tile, java.net.URL url)
 836     {
 837         PlaceNameChunk placeNameChunk = readTile(tile, url);
 838         if (placeNameChunk == null)
 839             return false;
 840
 841         this.memoryCache.add(tile, placeNameChunk);
 842         return true;
 843     }
 844
 845     private static PlaceNameChunk readTile(Tile tile, java.net.URL url)
 846     {
 847         java.io.InputStream is = null;
 848
 849         try
 850         {
 851             String path = url.getFile();
 852             path = path.replaceAll("%20", " "); // TODO: find a better way to get a path usable by FileInputStream
 853
 854             java.io.FileInputStream fis = new java.io.FileInputStream(path);
 855             java.io.BufferedInputStream buf = new java.io.BufferedInputStream(fis);
 856             is = new java.util.zip.GZIPInputStream(buf);
 857
 858             GMLPlaceNameSAXHandler handler = new GMLPlaceNameSAXHandler();
 859             javax.xml.parsers.SAXParserFactory.newInstance().newSAXParser().parse(is, handler);
 860             return handler.createPlaceNameChunk(tile.getPlaceNameService());
 861         }
 862         catch (Exception e)
 863         {
 864             Logging.logger().log(Level.FINE,
 865                 Logging.getMessage("layers.PlaceNameLayer.ExceptionAttemptingToReadFile", url.toString()), e);
 866         }
 867         finally
 868         {
 869             try
 870             {
 871                 if (is != null)
 872                     is.close();
 873             }
 874             catch (java.io.IOException e)
 875             {
 876                 Logging.logger().log(Level.FINE,
 877                     Logging.getMessage("layers.PlaceNameLayer.ExceptionAttemptingToReadFile", url.toString()), e);
 878             }
 879         }
 880
 881         return null;
 882     }
 883
 884     private void requestTile(Queue<Tile> queue, Tile tile)
 885     {
 886         if (tile.getPlaceNameService().isResourceAbsent(tile.getPlaceNameService().getTileNumber(
 887             tile.row, tile.column)))
 888             return;
 889         if (!queue.contains(tile))
 890             queue.offer(tile);
 891     }
 892
 893     private void sendRequests()
 894     {
 895         Tile tile;
 896         // Send threaded read tasks.
 897         while (!WorldWind.getTaskService().isFull() && (tile = this.readQueue.poll()) != null)
 898         {
 899             WorldWind.getTaskService().addTask(new RequestTask(this, tile));
 900         }
 901         // Send retriever tasks.
 902         while (!WorldWind.getRetrievalService().isFull() && (tile = this.downloadQueue.poll()) != null)
 903         {
 904             java.net.URL url;
 905             try
 906             {
 907                 url = tile.getRequestURL();
 908             }
 909             catch (java.net.MalformedURLException e)
 910             {
 911                 String message = Logging.getMessage("layers.PlaceNameLayer.ExceptionAttemptingToDownloadFile", tile);
 912                 Logging.logger().log(Level.FINE, message, e);
 913                 return;
 914             }
 915             WorldWind.getRetrievalService().runRetriever(new HTTPRetriever(url, new DownloadPostProcessor(this, tile)));
 916         }
 917     }
 918 }