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