protected boolean loadTile(Tile tile, java.net.URL url) {
if (WWIO.isFileOutOfDate(url, this.placeNameServiceSet.getExpiryTime())) {
// The file has expired. Delete it then request download of newer.
this.getDataFileStore().removeFile(url);
String message = Logging.getMessage("generic.DataFileExpired", url);
Logging.logger().fine(message);
return false;
}
PlaceNameChunk tileData;
synchronized (this.fileLock) {
tileData = readTileData(tile, url);
}
if (tileData == null) {
// Assume that something's wrong with the file and delete it.
this.getDataFileStore().removeFile(url);
tile.getPlaceNameService()
.markResourceAbsent(tile.getPlaceNameService().getTileNumber(tile.row, tile.column));
String message = Logging.getMessage("generic.DeletedCorruptDataFile", url);
Logging.logger().fine(message);
return false;
}
tile.setDataChunk(tileData);
WorldWind.getMemoryCache(Tile.class.getName()).add(tile.getFileCachePath(), tile);
return true;
}
protected static boolean isTileVisible(
DrawContext dc, Tile tile, double minDistanceSquared, double maxDistanceSquared) {
if (!tile.getSector().intersects(dc.getVisibleSector())) return false;
View view = dc.getView();
Position eyePos = view.getEyePosition();
if (eyePos == null) return false;
Angle lat =
clampAngle(
eyePos.getLatitude(),
tile.getSector().getMinLatitude(),
tile.getSector().getMaxLatitude());
Angle lon =
clampAngle(
eyePos.getLongitude(),
tile.getSector().getMinLongitude(),
tile.getSector().getMaxLongitude());
Vec4 p = dc.getGlobe().computePointFromPosition(lat, lon, 0d);
double distSquared = dc.getView().getEyePoint().distanceToSquared3(p);
//noinspection RedundantIfStatement
if (minDistanceSquared > distSquared || maxDistanceSquared < distSquared) return false;
return true;
}
protected void requestTile(DrawContext dc, Tile tile) {
Vec4 centroid = dc.getGlobe().computePointFromPosition(tile.getSector().getCentroid(), 0);
if (this.getReferencePoint() != null)
tile.setPriority(centroid.distanceTo3(this.getReferencePoint()));
RequestTask task = new RequestTask(tile, this);
this.getRequestQ().add(task);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final Tile tile = (Tile) o;
return !(this.getFileCachePath() != null
? !this.getFileCachePath().equals(tile.getFileCachePath())
: tile.getFileCachePath() != null);
}
public void run() {
if (this.tile.isTileInMemoryWithData()) return;
final java.net.URL tileURL =
this.layer.getDataFileStore().findFile(tile.getFileCachePath(), false);
if (tileURL != null) {
if (this.layer.loadTile(this.tile, tileURL)) {
tile.getPlaceNameService()
.unmarkResourceAbsent(
tile.getPlaceNameService().getTileNumber(tile.row, tile.column));
this.layer.firePropertyChange(AVKey.LAYER, null, this);
return;
}
}
this.layer.downloadTile(this.tile);
}
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final RequestTask that = (RequestTask) o;
// Don't include layer in comparison so that requests are shared among layers
return !(tile != null ? !tile.equals(that.tile) : that.tile != null);
}
public List<Tile> getTiles() {
if (tileKeys.isEmpty()) {
Tile[] tiles = buildTiles(this.placeNameService, this);
// load tileKeys
for (Tile t : tiles) {
tileKeys.add(t.getFileCachePath());
WorldWind.getMemoryCache(Tile.class.getName()).add(t.getFileCachePath(), t);
}
return Arrays.asList(tiles);
} else {
List<Tile> dataTiles = new ArrayList<Tile>();
for (String s : tileKeys) {
Tile t = (Tile) WorldWind.getMemoryCache(Tile.class.getName()).getObject(s);
if (t != null) {
dataTiles.add(t);
}
}
return dataTiles;
}
}
protected void downloadTile(final Tile tile, DownloadPostProcessor postProcessor) {
if (!this.isNetworkRetrievalEnabled()) return;
if (!WorldWind.getRetrievalService().isAvailable()) return;
java.net.URL url;
try {
url = tile.getRequestURL();
if (WorldWind.getNetworkStatus().isHostUnavailable(url)) return;
} catch (java.net.MalformedURLException e) {
Logging.logger()
.log(
java.util.logging.Level.SEVERE,
Logging.getMessage("layers.PlaceNameLayer.ExceptionCreatingUrl", tile),
e);
return;
}
Retriever retriever;
if ("http".equalsIgnoreCase(url.getProtocol()) || "https".equalsIgnoreCase(url.getProtocol())) {
if (postProcessor == null) postProcessor = new DownloadPostProcessor(this, tile);
retriever = new HTTPRetriever(url, postProcessor);
} else {
Logging.logger()
.severe(
Logging.getMessage("layers.PlaceNameLayer.UnknownRetrievalProtocol", url.toString()));
return;
}
// Apply any overridden timeouts.
Integer cto = AVListImpl.getIntegerValue(this, AVKey.URL_CONNECT_TIMEOUT);
if (cto != null && cto > 0) retriever.setConnectTimeout(cto);
Integer cro = AVListImpl.getIntegerValue(this, AVKey.URL_READ_TIMEOUT);
if (cro != null && cro > 0) retriever.setReadTimeout(cro);
Integer srl = AVListImpl.getIntegerValue(this, AVKey.RETRIEVAL_QUEUE_STALE_REQUEST_LIMIT);
if (srl != null && srl > 0) retriever.setStaleRequestLimit(srl);
WorldWind.getRetrievalService().runRetriever(retriever, tile.getPriority());
}
protected Tile[] buildTiles(PlaceNameService placeNameService, NavigationTile navTile) {
final Angle dLat = placeNameService.getTileDelta().getLatitude();
final Angle dLon = placeNameService.getTileDelta().getLongitude();
// Determine the row and column offset from the global tiling origin for the southwest tile
// corner
int firstRow = Tile.computeRow(dLat, navTile.navSector.getMinLatitude());
int firstCol = Tile.computeColumn(dLon, navTile.navSector.getMinLongitude());
int lastRow = Tile.computeRow(dLat, navTile.navSector.getMaxLatitude().subtract(dLat));
int lastCol = Tile.computeColumn(dLon, navTile.navSector.getMaxLongitude().subtract(dLon));
int nLatTiles = lastRow - firstRow + 1;
int nLonTiles = lastCol - firstCol + 1;
Tile[] tiles = new Tile[nLatTiles * nLonTiles];
Angle p1 = Tile.computeRowLatitude(firstRow, dLat);
for (int row = 0; row <= lastRow - firstRow; row++) {
Angle p2;
p2 = p1.add(dLat);
Angle t1 = Tile.computeColumnLongitude(firstCol, dLon);
for (int col = 0; col <= lastCol - firstCol; col++) {
Angle t2;
t2 = t1.add(dLon);
// Need offset row and column to correspond to total ro/col numbering
tiles[col + row * nLonTiles] =
new Tile(placeNameService, new Sector(p1, p2, t1, t2), row + firstRow, col + firstCol);
t1 = t2;
}
p1 = p2;
}
return tiles;
}
protected void drawOrRequestTile(
DrawContext dc,
Tile tile,
double minDisplayDistanceSquared,
double maxDisplayDistanceSquared) {
if (!isTileVisible(dc, tile, minDisplayDistanceSquared, maxDisplayDistanceSquared)) return;
if (tile.isTileInMemoryWithData()) {
PlaceNameChunk placeNameChunk = tile.getDataChunk();
if (placeNameChunk.numEntries > 0) {
Iterable<GeographicText> renderIter = placeNameChunk.makeIterable(dc);
this.placeNameRenderer.render(dc, renderIter);
}
return;
}
// Tile's data isn't available, so request it
if (!tile.getPlaceNameService()
.isResourceAbsent(tile.getPlaceNameService().getTileNumber(tile.row, tile.column))) {
this.requestTile(dc, tile);
}
}
protected static PlaceNameChunk readTileData(Tile tile, java.net.URL url) {
java.io.InputStream is = null;
try {
String path = url.getFile();
path =
path.replaceAll(
"%20", " "); // TODO: find a better way to get a path usable by FileInputStream
java.io.FileInputStream fis = new java.io.FileInputStream(path);
java.io.BufferedInputStream buf = new java.io.BufferedInputStream(fis);
is = new java.util.zip.GZIPInputStream(buf);
GMLPlaceNameSAXHandler handler = new GMLPlaceNameSAXHandler();
javax.xml.parsers.SAXParserFactory.newInstance().newSAXParser().parse(is, handler);
return handler.createPlaceNameChunk(tile.getPlaceNameService());
} catch (Exception e) {
// todo log actual error
Logging.logger()
.log(
Level.FINE,
Logging.getMessage(
"layers.PlaceNameLayer.ExceptionAttemptingToReadFile", url.toString()),
e);
} finally {
try {
if (is != null) is.close();
} catch (java.io.IOException e) {
Logging.logger()
.log(
Level.FINE,
Logging.getMessage(
"layers.PlaceNameLayer.ExceptionAttemptingToReadFile", url.toString()),
e);
}
}
return null;
}
private static MeshTile[] createTiles(LevelSet levelSet, int levelNumber, MeshCoords coords) {
Sector sector = levelSet.getSector();
Level level = levelSet.getLevel(levelNumber);
Angle dLat = level.getTileDelta().getLatitude();
Angle dLon = level.getTileDelta().getLongitude();
Angle latOrigin = levelSet.getTileOrigin().getLatitude();
Angle lonOrigin = levelSet.getTileOrigin().getLongitude();
// Determine the row and column offset from the common World Wind global tiling origin.
int firstRow = Tile.computeRow(dLat, sector.getMinLatitude(), latOrigin);
int firstCol = Tile.computeColumn(dLon, sector.getMinLongitude(), lonOrigin);
int lastRow = Tile.computeRow(dLat, sector.getMaxLatitude(), latOrigin);
int lastCol = Tile.computeColumn(dLon, sector.getMaxLongitude(), lonOrigin);
int numLatTiles = lastRow - firstRow + 1;
int numLonTiles = lastCol - firstCol + 1;
AffineTransform sectorTransform = createTransform(sector, coords);
MeshTile[] tiles = new MeshTile[numLatTiles * numLonTiles];
int index = 0;
Angle p1 = Tile.computeRowLatitude(firstRow, dLat, latOrigin);
for (int row = firstRow; row <= lastRow; row++) {
Angle p2 = p1.add(dLat);
Angle t1 = Tile.computeColumnLongitude(firstCol, dLon, lonOrigin);
for (int col = firstCol; col <= lastCol; col++) {
Angle t2 = t1.add(dLon);
Sector tileSector = new Sector(p1, p2, t1, t2);
MeshCoords tileCoords = transformSector(sectorTransform, tileSector);
tiles[index++] = new MeshTile(tileSector, level, row, col, tileCoords);
t1 = t2;
}
p1 = p2;
}
return tiles;
}
public int hashCode() {
return (tile != null ? tile.hashCode() : 0);
}
protected boolean isTileInMemoryWithData() {
Tile t =
(Tile) WorldWind.getMemoryCache(Tile.class.getName()).getObject(this.getFileCachePath());
return !(t == null || t.getDataChunk() == null);
}