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 2490 2007-08-02 18:24:12Z dcollins $
  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     protected void doRender(DrawContext dc)
 423     {
 424         boolean enableDepthTest = this.isEnableDepthTest(dc);
 425
 426         int serviceCount = this.placeNameServiceSet.getServiceCount();
 427         for (int i = 0; i < serviceCount; i++)
 428         {
 429             PlaceNameService placeNameService = this.placeNameServiceSet.getService(i);
 430             if (!isServiceVisible(dc, placeNameService))
 431                 continue;
 432
 433             double minDist = placeNameService.getMinDisplayDistance();
 434             double maxDist = placeNameService.getMaxDisplayDistance();
 435             double minDistSquared = minDist * minDist;
 436             double maxDistSquared = maxDist * maxDist;
 437
 438             Tile[] tiles = this.tiles.get(i);
 439             for (Tile tile : tiles)
 440             {
 441                 try
 442                 {
 443                     drawOrRequestTile(dc, tile, minDistSquared, maxDistSquared, enableDepthTest);
 444                 }
 445                 catch (Exception e)
 446                 {
 447                     Logging.logger().log(Level.FINE, Logging.getMessage("layers.PlaceNameLayer.ExceptionRenderingTile"),
 448                         e);
 449                 }
 450             }
 451         }
 452
 453         this.sendRequests();
 454     }
 455
 456     private boolean isEnableDepthTest(DrawContext dc)
 457     {
 458         Position eyePos = dc.getView().getEyePosition();
 459         if (eyePos == null)
 460             return false;
 461
 462         double altitude = eyePos.getElevation();
 463         return altitude < (dc.getVerticalExaggeration() * dc.getGlobe().getMaxElevation());
 464     }
 465
 466     private void drawOrRequestTile(DrawContext dc, Tile tile, double minDisplayDistanceSquared,
 467         double maxDisplayDistanceSquared, boolean enableDepthTest)
 468     {
 469         if (!isTileVisible(dc, tile, minDisplayDistanceSquared, maxDisplayDistanceSquared))
 470             return;
 471
 472         Object cacheObj = this.memoryCache.getObject(tile);
 473         if (cacheObj == null)
 474         {
 475             this.requestTile(this.readQueue, tile);
 476             return;
 477         }
 478
 479         if (!(cacheObj instanceof PlaceNameChunk))
 480             return;
 481
 482         PlaceNameChunk placeNameChunk = (PlaceNameChunk) cacheObj;
 483         Iterator<PlaceName> renderIter = placeNameChunk.createRenderIterator(dc);
 484         placeNameRenderer.render(dc, renderIter, enableDepthTest);
 485     }
 486
 487     private static boolean isServiceVisible(DrawContext dc, PlaceNameService placeNameService)
 488     {
 489         if (!placeNameService.isEnabled())
 490             return false;
 491         //noinspection SimplifiableIfStatement
 492         if (dc.getVisibleSector() != null && !placeNameService.getSector().intersects(dc.getVisibleSector()))
 493             return false;
 494
 495         return placeNameService.getExtent(dc).intersects(dc.getView().getFrustumInModelCoordinates());
 496     }
 497
 498     private static boolean isTileVisible(DrawContext dc, Tile tile, double minDistanceSquared,
 499         double maxDistanceSquared)
 500     {
 501         if (!tile.getSector().intersects(dc.getVisibleSector()))
 502             return false;
 503
 504         View view = dc.getView();
 505         Position eyePos = view.getEyePosition();
 506         if (eyePos == null)
 507             return false;
 508
 509         Angle lat = clampAngle(eyePos.getLatitude(), tile.getSector().getMinLatitude(),
 510             tile.getSector().getMaxLatitude());
 511         Angle lon = clampAngle(eyePos.getLongitude(), tile.getSector().getMinLongitude(),
 512             tile.getSector().getMaxLongitude());
 513         Vec4 p = dc.getGlobe().computePointFromPosition(lat, lon, 0d);
 514         double distSquared = dc.getView().getEyePoint().distanceToSquared3(p);
 515         //noinspection RedundantIfStatement
 516         if (minDistanceSquared > distSquared || maxDistanceSquared < distSquared)
 517             return false;
 518
 519         return true;
 520     }
 521
 522     private static boolean isNameVisible(DrawContext dc, PlaceNameService service, Position namePosition)
 523     {
 524         double elevation = dc.getVerticalExaggeration() * namePosition.getElevation();
 525         Vec4 namePoint = dc.getGlobe().computePointFromPosition(namePosition.getLatitude(),
 526             namePosition.getLongitude(), elevation);
 527         Vec4 eyeVec = dc.getView().getEyePoint();
 528
 529         double dist = eyeVec.distanceTo3(namePoint);
 530         return dist >= service.getMinDisplayDistance() && dist <= service.getMaxDisplayDistance();
 531     }
 532
 533     private static Angle clampAngle(Angle a, Angle min, Angle max)
 534     {
 535         return a.compareTo(min) < 0 ? min : (a.compareTo(max) > 0 ? max : a);
 536     }
 537
 538     // ============== Image Reading and Downloading ======================= //
 539     // ============== Image Reading and Downloading ======================= //
 540     // ============== Image Reading and Downloading ======================= //
 541
 542     private static final int MAX_REQUESTS = 64;
 543     private final Queue<Tile> downloadQueue = new LinkedBlockingQueue<Tile>(MAX_REQUESTS);
 544     private final Queue<Tile> readQueue = new LinkedBlockingQueue<Tile>(MAX_REQUESTS);
 545
 546     private static class RequestTask implements Runnable
 547     {
 548         final PlaceNameLayer layer;
 549         final Tile tile;
 550
 551         RequestTask(PlaceNameLayer layer, Tile tile)
 552         {
 553             this.layer = layer;
 554             this.tile = tile;
 555         }
 556
 557         @Override
 558         public boolean equals(Object o)
 559         {
 560             if (this == o)
 561                 return true;
 562             if (o == null || this.getClass() != o.getClass())
 563                 return false;
 564
 565             final RequestTask other = (RequestTask) o;
 566
 567             // Don't include layer in comparison so that requests are shared among layers
 568             return !(this.tile != null ? !this.tile.equals(other.tile) : other.tile != null);
 569         }
 570
 571         @Override
 572         public int hashCode()
 573         {
 574             return (this.tile != null ? this.tile.hashCode() : 0);
 575         }
 576
 577         public void run()
 578         {
 579             synchronized (tile)
 580             {
 581                 if (this.layer.memoryCache.getObject(this.tile) != null)
 582                     return;
 583
 584                 final java.net.URL tileURL = WorldWind.getDataFileCache().findFile(tile.getFileCachePath(), false);
 585                 if (tileURL != null)
 586                 {
 587                     if (this.layer.loadTile(this.tile, tileURL))
 588                     {
 589                         tile.getPlaceNameService().unmarkResourceAbsent(tile.getPlaceNameService().getTileNumber(
 590                             tile.row,
 591                             tile.column));
 592                         this.layer.firePropertyChange(AVKey.LAYER, null, this);
 593                     }
 594                     else
 595                     {
 596                         // Assume that something's wrong with the file and delete it.
 597                         WorldWind.getDataFileCache().removeFile(tileURL);
 598                         tile.getPlaceNameService().markResourceAbsent(tile.getPlaceNameService().getTileNumber(tile.row,
 599                             tile.column));
 600                         String message = Logging.getMessage("generic.DeletedCorruptDataFile", tileURL);
 601                         Logging.logger().fine(message);
 602                     }
 603                     return;
 604                 }
 605             }
 606
 607             this.layer.requestTile(this.layer.downloadQueue, this.tile);
 608         }
 609
 610         public String toString()
 611         {
 612             return this.tile.toString();
 613         }
 614     }
 615
 616     private static class DownloadPostProcessor implements RetrievalPostProcessor
 617     {
 618         final PlaceNameLayer layer;
 619         final Tile tile;
 620
 621         private DownloadPostProcessor(PlaceNameLayer layer, Tile tile)
 622         {
 623             this.layer = layer;
 624             this.tile = tile;
 625         }
 626
 627         public java.nio.ByteBuffer run(Retriever retriever)
 628         {
 629             if (retriever == null)
 630             {
 631                 String msg = Logging.getMessage("nullValue.RetrieverIsNull");
 632                 Logging.logger().fine(msg);
 633                 throw new IllegalArgumentException(msg);
 634             }
 635
 636             if (!retriever.getState().equals(Retriever.RETRIEVER_STATE_SUCCESSFUL))
 637                 return null;
 638
 639             if (!(retriever instanceof URLRetriever))
 640                 return null;
 641
 642             try
 643             {
 644                 if (retriever instanceof HTTPRetriever)
 645                 {
 646                     HTTPRetriever httpRetriever = (HTTPRetriever) retriever;
 647                     if (httpRetriever.getResponseCode() == java.net.HttpURLConnection.HTTP_NO_CONTENT)
 648                     {
 649                         // Mark tile as missing to avoid further attempts
 650                         tile.getPlaceNameService().markResourceAbsent(tile.getPlaceNameService().getTileNumber(tile.row,
 651                             tile.column));
 652                         return null;
 653                     }
 654                 }
 655
 656                 URLRetriever urlRetriever = (URLRetriever) retriever;
 657                 java.nio.ByteBuffer buffer = urlRetriever.getBuffer();
 658
 659                 synchronized (tile)
 660                 {
 661                     final java.io.File cacheFile = WorldWind.getDataFileCache().newFile(this.tile.getFileCachePath());
 662                     if (cacheFile == null)
 663                     {
 664                         String msg = Logging.getMessage("generic.CantCreateCacheFile", this.tile.getFileCachePath());
 665                         Logging.logger().fine(msg);
 666                         return null;
 667                     }
 668
 669                     if (cacheFile.exists())
 670                         return buffer; // info is already here; don't need to do anything
 671
 672                     if (buffer != null)
 673                     {
 674                         WWIO.saveBuffer(buffer, cacheFile);
 675                         this.layer.firePropertyChange(AVKey.LAYER, null, this);
 676                         return buffer;
 677                     }
 678                 }
 679             }
 680             catch (java.io.IOException e)
 681             {
 682                 Logging.logger().log(Level.FINE, Logging.getMessage(
 683                     "layers.PlaceNameLayer.ExceptionSavingRetrievedFile", this.tile.getFileCachePath()), e);
 684             }
 685
 686             return null;
 687         }
 688     }
 689
 690     private static class GMLPlaceNameSAXHandler extends org.xml.sax.helpers.DefaultHandler
 691     {
 692         static final String GML_FEATURE_MEMBER = "gml:featureMember";
 693         static final String TOPP_FULL_NAME_ND = "topp:full_name_nd";
 694         static final String TOPP_LATITUDE = "topp:latitude";
 695         static final String TOPP_LONGITUDE = "topp:longitude";
 696         final LinkedList<String> internedQNameStack = new LinkedList<String>();
 697         boolean inBeginEndPair = false;
 698         StringBuilder latBuffer = new StringBuilder();
 699         StringBuilder lonBuffer = new StringBuilder();
 700
 701         StringBuilder textArray = new StringBuilder();
 702         int[] textIndexArray = new int[16];
 703         double[] latlonArray = new double[16];
 704         int numEntries = 0;
 705
 706         GMLPlaceNameSAXHandler()
 707         {
 708         }
 709
 710         PlaceNameChunk createPlaceNameChunk(PlaceNameService service)
 711         {
 712             return new PlaceNameChunk(service, this.textArray, this.textIndexArray, this.latlonArray, this.numEntries);
 713         }
 714
 715         void beginEntry()
 716         {
 717             int textIndex = this.textArray.length();
 718             this.textIndexArray = append(this.textIndexArray, this.numEntries, textIndex);
 719             this.inBeginEndPair = true;
 720         }
 721
 722         void endEntry()
 723         {
 724             double lat = this.parseDouble(this.latBuffer);
 725             double lon = this.parseDouble(this.lonBuffer);
 726             int numLatLon = 2 * this.numEntries;
 727             this.latlonArray = this.append(this.latlonArray, numLatLon, lat);
 728             numLatLon++;
 729             this.latlonArray = this.append(this.latlonArray, numLatLon, lon);
 730
 731             this.latBuffer.delete(0, this.latBuffer.length());
 732             this.lonBuffer.delete(0, this.lonBuffer.length());
 733             this.inBeginEndPair = false;
 734             this.numEntries++;
 735         }
 736
 737         double parseDouble(StringBuilder sb)
 738         {
 739             double value = 0;
 740             try
 741             {
 742                 value = Double.parseDouble(sb.toString());
 743             }
 744             catch (NumberFormatException e)
 745             {
 746                 Logging.logger().log(Level.FINE,
 747                     Logging.getMessage("layers.PlaceNameLayer.ExceptionAttemptingToReadFile", ""), e);
 748             }
 749             return value;
 750         }
 751
 752         int[] append(int[] array, int index, int value)
 753         {
 754             if (index >= array.length)
 755                 array = this.resizeArray(array);
 756             array[index] = value;
 757             return array;
 758         }
 759
 760         int[] resizeArray(int[] oldArray)
 761         {
 762             int newSize = 2 * oldArray.length;
 763             int[] newArray = new int[newSize];
 764             System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
 765             return newArray;
 766         }
 767
 768         double[] append(double[] array, int index, double value)
 769         {
 770             if (index >= array.length)
 771                 array = this.resizeArray(array);
 772             array[index] = value;
 773             return array;
 774         }
 775
 776         double[] resizeArray(double[] oldArray)
 777         {
 778             int newSize = 2 * oldArray.length;
 779             double[] newArray = new double[newSize];
 780             System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
 781             return newArray;
 782         }
 783
 784         public void characters(char ch[], int start, int length)
 785         {
 786             if (!this.inBeginEndPair)
 787                 return;
 788
 789             // Top of QName stack is an interned string,
 790             // so we can use pointer comparison.
 791             String internedTopQName = this.internedQNameStack.getFirst();
 792
 793             StringBuilder sb = null;
 794             if (TOPP_LATITUDE == internedTopQName)
 795                 sb = this.latBuffer;
 796             else if (TOPP_LONGITUDE == internedTopQName)
 797                 sb = this.lonBuffer;
 798             else if (TOPP_FULL_NAME_ND == internedTopQName)
 799                 sb = this.textArray;
 800
 801             if (sb != null)
 802                 sb.append(ch, start, length);
 803         }
 804
 805         public void startElement(String uri, String localName, String qName, org.xml.sax.Attributes attributes)
 806         {
 807             // Don't validate uri, localName or attributes because they aren't used.
 808             // Intern the qName string so we can use pointer comparison.
 809             String internedQName = qName.intern();
 810             if (GML_FEATURE_MEMBER == internedQName)
 811                 this.beginEntry();
 812             this.internedQNameStack.addFirst(internedQName);
 813         }
 814
 815         public void endElement(String uri, String localName, String qName)
 816         {
 817             // Don't validate uri or localName because they aren't used.
 818             // Intern the qName string so we can use pointer comparison.
 819             String internedQName = qName.intern();
 820             if (GML_FEATURE_MEMBER == internedQName)
 821                 this.endEntry();
 822             this.internedQNameStack.removeFirst();
 823         }
 824     }
 825
 826     private boolean loadTile(Tile tile, java.net.URL url)
 827     {
 828         PlaceNameChunk placeNameChunk = readTile(tile, url);
 829         if (placeNameChunk == null)
 830             return false;
 831
 832         this.memoryCache.add(tile, placeNameChunk);
 833         return true;
 834     }
 835
 836     private static PlaceNameChunk readTile(Tile tile, java.net.URL url)
 837     {
 838         java.io.InputStream is = null;
 839
 840         try
 841         {
 842             String path = url.getFile();
 843             path = path.replaceAll("%20", " "); // TODO: find a better way to get a path usable by FileInputStream
 844
 845             java.io.FileInputStream fis = new java.io.FileInputStream(path);
 846             java.io.BufferedInputStream buf = new java.io.BufferedInputStream(fis);
 847             is = new java.util.zip.GZIPInputStream(buf);
 848
 849             GMLPlaceNameSAXHandler handler = new GMLPlaceNameSAXHandler();
 850             javax.xml.parsers.SAXParserFactory.newInstance().newSAXParser().parse(is, handler);
 851             return handler.createPlaceNameChunk(tile.getPlaceNameService());
 852         }
 853         catch (Exception e)
 854         {
 855             Logging.logger().log(Level.FINE,
 856                 Logging.getMessage("layers.PlaceNameLayer.ExceptionAttemptingToReadFile", url.toString()), e);
 857         }
 858         finally
 859         {
 860             try
 861             {
 862                 if (is != null)
 863                     is.close();
 864             }
 865             catch (java.io.IOException e)
 866             {
 867                 Logging.logger().log(Level.FINE,
 868                     Logging.getMessage("layers.PlaceNameLayer.ExceptionAttemptingToReadFile", url.toString()), e);
 869             }
 870         }
 871
 872         return null;
 873     }
 874
 875     private void requestTile(Queue<Tile> queue, Tile tile)
 876     {
 877         if (tile.getPlaceNameService().isResourceAbsent(tile.getPlaceNameService().getTileNumber(
 878             tile.row, tile.column)))
 879             return;
 880         if (!queue.contains(tile))
 881             queue.offer(tile);
 882     }
 883
 884     private void sendRequests()
 885     {
 886         Tile tile;
 887         // Send threaded read tasks.
 888         while (!WorldWind.getTaskService().isFull() && (tile = this.readQueue.poll()) != null)
 889         {
 890             WorldWind.getTaskService().addTask(new RequestTask(this, tile));
 891         }
 892         // Send retriever tasks.
 893         while (!WorldWind.getRetrievalService().isFull() && (tile = this.downloadQueue.poll()) != null)
 894         {
 895             java.net.URL url;
 896             try
 897             {
 898                 url = tile.getRequestURL();
 899             }
 900             catch (java.net.MalformedURLException e)
 901             {
 902                 String message = Logging.getMessage("layers.PlaceNameLayer.ExceptionAttemptingToDownloadFile", tile);
 903                 Logging.logger().log(Level.FINE, message, e);
 904                 return;
 905             }
 906             WorldWind.getRetrievalService().runRetriever(new HTTPRetriever(url, new DownloadPostProcessor(this, tile)));
 907         }
 908     }
 909 }