gov/nasa/worldwind/util/LevelSet.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7 package gov.nasa.worldwind.util;
   8
   9 import gov.nasa.worldwind.WWObjectImpl;
  10 import gov.nasa.worldwind.avlist.*;
  11 import gov.nasa.worldwind.geom.*;
  12
  13 import java.net.*;
  14 import java.util.*;
  15
  16 /**
  17  * @author tag
  18  * @version $Id: LevelSet.java 2786 2007-09-10 17:41:00Z tgaskins $
  19  */
  20 public class LevelSet extends WWObjectImpl
  21 {
  22     public static final class SectorResolution
  23     {
  24         private final int levelNumber;
  25         private final Sector sector;
  26
  27         public SectorResolution(Sector sector, int levelNumber)
  28         {
  29             this.levelNumber = levelNumber;
  30             this.sector = sector;
  31         }
  32     }
  33
  34     private final Sector sector;
  35     private final LatLon levelZeroTileDelta;
  36     private final int numLevelZeroColumns;
  37     private final java.util.ArrayList<Level> levels = new java.util.ArrayList<Level>();
  38     private final SectorResolution[] sectorLevelLimits;
  39
  40     public LevelSet(AVList params)
  41     {
  42         StringBuffer sb = new StringBuffer();
  43
  44         Object o = params.getValue(AVKey.LEVEL_ZERO_TILE_DELTA);
  45         if (o == null || !(o instanceof LatLon))
  46             sb.append(Logging.getMessage("term.tileDelta"));
  47
  48         o = params.getValue(AVKey.SECTOR);
  49         if (o == null || !(o instanceof Sector))
  50             sb.append(Logging.getMessage("term.sector"));
  51
  52         int numLevels = 0;
  53         o = params.getValue(AVKey.NUM_LEVELS);
  54         if (o == null || !(o instanceof Integer) || (numLevels = (Integer) o) < 1)
  55             sb.append(Logging.getMessage("term.numLevels"));
  56
  57         int numEmptyLevels = 0;
  58         o = params.getValue(AVKey.NUM_EMPTY_LEVELS);
  59         if (o == null || !(o instanceof Integer) || (numEmptyLevels = (Integer) o) < 0)
  60             sb.append(Logging.getMessage("term.numEMptyLevels"));
  61
  62         String[] inactiveLevels = null;
  63         o = params.getValue(AVKey.INACTIVE_LEVELS);
  64         if (o != null && !(o instanceof String))
  65             sb.append(Logging.getMessage("term.sector")); // TODO field name
  66         else if (o != null)
  67             inactiveLevels = ((String) o).split(",");
  68
  69         SectorResolution[] sectorLimits = null;
  70         o = params.getValue(AVKey.SECTOR_RESOLUTION_LIMITS);
  71         if (o != null && !(o instanceof SectorResolution[]))
  72         {
  73             sb.append(Logging.getMessage("term.sectorResolutionLimits"));
  74         }
  75         else if (o != null)
  76         {
  77             sectorLimits = (SectorResolution[]) o;
  78             for (SectorResolution sr : sectorLimits)
  79             {
  80                 if (sr.levelNumber > numLevels - 1)
  81                 {
  82                     String message =
  83                         Logging.getMessage("LevelSet.sectorResolutionLimitsTooHigh", sr.levelNumber, numLevels - 1);
  84                     Logging.logger().warning(message);
  85                     break;
  86                 }
  87             }
  88         }
  89         this.sectorLevelLimits = sectorLimits;
  90
  91         if (sb.length() > 0)
  92         {
  93             String message = Logging.getMessage("layers.LevelSet.InvalidLevelDescriptorFields", sb.toString());
  94             Logging.logger().severe(message);
  95             throw new IllegalArgumentException(message);
  96         }
  97
  98         this.levelZeroTileDelta = (LatLon) params.getValue(AVKey.LEVEL_ZERO_TILE_DELTA);
  99         this.sector = (Sector) params.getValue(AVKey.SECTOR);
 100
 101         params = params.copy(); // copy so as not to modify the user's params
 102
 103         TileUrlBuilder tub = (TileUrlBuilder) params.getValue(AVKey.TILE_URL_BUILDER);
 104         if (tub == null)
 105         {
 106             params.setValue(AVKey.TILE_URL_BUILDER, new TileUrlBuilder()
 107             {
 108                 public URL getURL(Tile tile) throws MalformedURLException
 109                 {
 110                     StringBuffer sb = new StringBuffer(tile.getLevel().getService());
 111                     if (sb.lastIndexOf("?") != sb.length() - 1)
 112                         sb.append("?");
 113                     sb.append("T=");
 114                     sb.append(tile.getLevel().getDataset());
 115                     sb.append("&L=");
 116                     sb.append(tile.getLevel().getLevelName());
 117                     sb.append("&X=");
 118                     sb.append(tile.getColumn());
 119                     sb.append("&Y=");
 120                     sb.append(tile.getRow());
 121
 122                     return new URL(sb.toString());
 123                 }
 124             });
 125         }
 126
 127         for (int i = 0; i < numLevels; i++)
 128         {
 129             params.setValue(AVKey.LEVEL_NAME, i < numEmptyLevels ? "" : Integer.toString(i - numEmptyLevels));
 130             params.setValue(AVKey.LEVEL_NUMBER, i);
 131
 132             Angle latDelta = this.levelZeroTileDelta.getLatitude().divide(Math.pow(2, i));
 133             Angle lonDelta = this.levelZeroTileDelta.getLongitude().divide(Math.pow(2, i));
 134             params.setValue(AVKey.TILE_DELTA, new LatLon(latDelta, lonDelta));
 135
 136             this.levels.add(new Level(params));
 137         }
 138
 139         if (inactiveLevels != null)
 140         {
 141             for (String s : inactiveLevels)
 142             {
 143                 int i = Integer.parseInt(s);
 144                 this.getLevel(i).setActive(false);
 145             }
 146         }
 147
 148         if (this.sectorLevelLimits != null)
 149         {
 150             Arrays.sort(this.sectorLevelLimits, new Comparator<SectorResolution>()
 151             {
 152                 public int compare(SectorResolution sra, SectorResolution srb)
 153                 {
 154                     // sort order is deliberately backwards in order to list higher-resolution sectors first
 155                     return sra.levelNumber < srb.levelNumber ? 1 : sra.levelNumber == srb.levelNumber ? 0 : -1;
 156                 }
 157             });
 158         }
 159
 160         this.numLevelZeroColumns =
 161             (int) Math.round(this.sector.getDeltaLon().divide(this.levelZeroTileDelta.getLongitude()));
 162     }
 163
 164     public LevelSet(LevelSet source)
 165     {
 166         if (source == null)
 167         {
 168             String msg = Logging.getMessage("nullValue.LevelSetIsNull");
 169             Logging.logger().severe(msg);
 170             throw new IllegalArgumentException(msg);
 171         }
 172
 173         this.levelZeroTileDelta = source.levelZeroTileDelta;
 174         this.sector = source.sector;
 175         this.numLevelZeroColumns = source.numLevelZeroColumns;
 176         this.sectorLevelLimits = source.sectorLevelLimits;
 177
 178         for (Level level : source.levels)
 179         {
 180             this.levels.add(level); // Levels are final, so it's safe to copy references.
 181         }
 182     }
 183
 184     public final Sector getSector()
 185     {
 186         return this.sector;
 187     }
 188
 189     public final LatLon getLevelZeroTileDelta()
 190     {
 191         return this.levelZeroTileDelta;
 192     }
 193
 194     public final ArrayList<Level> getLevels()
 195     {
 196         return this.levels;
 197     }
 198
 199     public final Level getLevel(int levelNumber)
 200     {
 201         return (levelNumber >= 0 && levelNumber < this.levels.size()) ? this.levels.get(levelNumber) : null;
 202     }
 203
 204     public final int getNumLevels()
 205     {
 206         return this.levels.size();
 207     }
 208
 209     public final Level getFirstLevel()
 210     {
 211         return this.getLevel(0);
 212     }
 213
 214     public final Level getLastLevel()
 215     {
 216         return this.getLevel(this.getNumLevels() - 1);
 217     }
 218
 219     public final Level getLastLevel(Sector sector)
 220     {
 221         Level level = this.getLevel(this.getNumLevels() - 1);
 222
 223         if (this.sectorLevelLimits != null)
 224             for (SectorResolution sr : this.sectorLevelLimits)
 225             {
 226                 if (sr.sector.intersects(sector) && sr.levelNumber <= level.getLevelNumber())
 227                 {
 228                     level = this.getLevel(sr.levelNumber);
 229                     break;
 230                 }
 231             }
 232
 233         return level;
 234     }
 235
 236     public final Level getLastLevel(Angle latitude, Angle longitude)
 237     {
 238         Level level = this.getLevel(this.getNumLevels() - 1);
 239
 240         if (this.sectorLevelLimits != null)
 241             for (SectorResolution sr : this.sectorLevelLimits)
 242             {
 243                 if (sr.sector.contains(latitude, longitude) && sr.levelNumber <= level.getLevelNumber())
 244                 {
 245                     level = this.getLevel(sr.levelNumber);
 246                     break;
 247                 }
 248             }
 249
 250         return level;
 251     }
 252
 253     public final boolean isFinalLevel(int levelNum)
 254     {
 255         return levelNum == this.getNumLevels() - 1;
 256     }
 257
 258     public final boolean isLevelEmpty(int levelNumber)
 259     {
 260         return this.levels.get(levelNumber).isEmpty();
 261     }
 262
 263     private int numColumnsInLevel(Level level)
 264     {
 265         int levelDelta = level.getLevelNumber() - this.getFirstLevel().getLevelNumber();
 266         double twoToTheN = Math.pow(2, levelDelta);
 267         return (int) (twoToTheN * this.numLevelZeroColumns);
 268     }
 269
 270     private long getTileNumber(Tile tile)
 271     {
 272         return tile.getRow() * this.numColumnsInLevel(tile.getLevel()) + tile.getColumn();
 273     }
 274
 275     /**
 276      * Instructs the level set that a tile is likely to be absent.
 277      *
 278      * @param tile The tile to mark as having an absent resource.
 279      * @throws IllegalArgumentException if <code>tile</code> is null
 280      */
 281     public final void markResourceAbsent(Tile tile)
 282     {
 283         if (tile == null)
 284         {
 285             String msg = Logging.getMessage("nullValue.TileIsNull");
 286             Logging.logger().severe(msg);
 287             throw new IllegalArgumentException(msg);
 288         }
 289
 290         tile.getLevel().markResourceAbsent(this.getTileNumber(tile));
 291     }
 292
 293     /**
 294      * Indicates whether a tile has been marked as absent.
 295      *
 296      * @param tile The tile in question.
 297      * @return <code>true</code> if the tile is marked absent, otherwise <code>false</code>.
 298      * @throws IllegalArgumentException if <code>tile</code> is null
 299      */
 300     public final boolean isResourceAbsent(Tile tile)
 301     {
 302         if (tile == null)
 303         {
 304             String msg = Logging.getMessage("nullValue.TileIsNull");
 305             Logging.logger().severe(msg);
 306             throw new IllegalArgumentException(msg);
 307         }
 308
 309         if (tile.getLevel().isEmpty())
 310             return true;
 311
 312         int tileNumber = tile.getRow() * this.numColumnsInLevel(tile.getLevel()) + tile.getColumn();
 313         return tile.getLevel().isResourceAbsent(tileNumber);
 314     }
 315
 316     /**
 317      * Removes the absent-tile mark associated with a tile, if one is associatied.
 318      *
 319      * @param tile The tile to unmark.
 320      * @throws IllegalArgumentException if <code>tile</code> is null
 321      */
 322     public final void unmarkResourceAbsent(Tile tile)
 323     {
 324         if (tile == null)
 325         {
 326             String msg = Logging.getMessage("nullValue.TileIsNull");
 327             Logging.logger().severe(msg);
 328             throw new IllegalArgumentException(msg);
 329         }
 330
 331         tile.getLevel().unmarkResourceAbsent(this.getTileNumber(tile));
 332     }
 333
 334     // Create the tile corresponding to a specified key.
 335     public Sector computeSectorForKey(TileKey key)
 336     {
 337         if (key == null)
 338         {
 339             String msg = Logging.getMessage("nullValue.KeyIsNull");
 340             Logging.logger().severe(msg);
 341             throw new IllegalArgumentException(msg);
 342         }
 343
 344         Level level = this.getLevel(key.getLevelNumber());
 345
 346         // Compute the tile's SW lat/lon based on its row/col in the level's data set.
 347         Angle dLat = level.getTileDelta().getLatitude();
 348         Angle dLon = level.getTileDelta().getLongitude();
 349
 350         Angle minLatitude = Tile.computeRowLatitude(key.getRow(), dLat);
 351         Angle minLongitude = Tile.computeColumnLongitude(key.getColumn(), dLon);
 352
 353         return new Sector(minLatitude, minLatitude.add(dLat), minLongitude, minLongitude.add(dLon));
 354     }
 355
 356     // Create the tile corresponding to a specified key.
 357     public Tile createTile(TileKey key)
 358     {
 359         if (key == null)
 360         {
 361             String msg = Logging.getMessage("nullValue.KeyIsNull");
 362             Logging.logger().severe(msg);
 363             throw new IllegalArgumentException(msg);
 364         }
 365
 366         Level level = this.getLevel(key.getLevelNumber());
 367
 368         // Compute the tile's SW lat/lon based on its row/col in the level's data set.
 369         Angle dLat = level.getTileDelta().getLatitude();
 370         Angle dLon = level.getTileDelta().getLongitude();
 371
 372         Angle minLatitude = Tile.computeRowLatitude(key.getRow(), dLat);
 373         Angle minLongitude = Tile.computeColumnLongitude(key.getColumn(), dLon);
 374
 375         Sector tileSector = new Sector(minLatitude, minLatitude.add(dLat), minLongitude, minLongitude.add(dLon));
 376
 377         return new Tile(tileSector, level, key.getRow(), key.getColumn());
 378     }
 379 }