gov/nasa/worldwind/Tile.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;
   8
   9 import gov.nasa.worldwind.geom.*;
  10
  11 /**
  12  * @author tag
  13  * @version $Id: Tile.java 2029 2007-06-14 02:44:20Z tgaskins $
  14  */
  15 public class Tile implements Comparable<Tile>, Cacheable
  16 {
  17     private final Sector sector;
  18     private final gov.nasa.worldwind.Level level;
  19     private final int row;
  20     private final int column;
  21     private final TileKey tileKey;
  22     private double priority = Double.MAX_VALUE; // Default is minimum priority
  23     // The following is late bound because it's only selectively needed and costly to create
  24     private String path;
  25
  26     public Tile(Sector sector, Level level, int row, int column)
  27     {
  28         if (sector == null)
  29         {
  30             String msg = WorldWind.retrieveErrMsg("nullValue.SectorIsNull");
  31             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
  32             throw new IllegalArgumentException(msg);
  33         }
  34         if (level == null)
  35         {
  36             String msg = WorldWind.retrieveErrMsg("nullValue.LevelIsNull");
  37             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
  38             throw new IllegalArgumentException(msg);
  39         }
  40         if (row < 0)
  41         {
  42             String msg = WorldWind.retrieveErrMsg("generic.rowIndexOutOfRange");
  43             msg += WorldWind.retrieveErrMsg("punctuation.space");
  44             msg += String.valueOf(row);
  45
  46             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
  47             throw new IllegalArgumentException(msg);
  48         }
  49         if (column < 0)
  50         {
  51             String msg = WorldWind.retrieveErrMsg("generic.columnIndexOutOfRange");
  52             msg += WorldWind.retrieveErrMsg("punctuation.space");
  53             msg += String.valueOf(row);
  54
  55             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
  56             throw new IllegalArgumentException(msg);
  57         }
  58
  59         this.sector = sector;
  60         this.level = level;
  61         this.row = row;
  62         this.column = column;
  63         this.tileKey = new TileKey(this);
  64         this.path = null;
  65     }
  66
  67     public Tile(Sector sector, gov.nasa.worldwind.Level level)
  68     {
  69         if (sector == null)
  70         {
  71             String msg = WorldWind.retrieveErrMsg("nullValue.SectorIsNull");
  72             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
  73             throw new IllegalArgumentException(msg);
  74         }
  75         if (level == null)
  76         {
  77             String msg = WorldWind.retrieveErrMsg("nullValue.LevelIsNull");
  78             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
  79             throw new IllegalArgumentException(msg);
  80         }
  81
  82         this.sector = sector;
  83         this.level = level;
  84         this.row = Tile.computeRow(sector.getDeltaLat(), sector.getMinLatitude());
  85         this.column = Tile.computeColumn(sector.getDeltaLon(), sector.getMinLongitude());
  86         this.tileKey = new TileKey(this);
  87         this.path = null;
  88     }
  89
  90     public Tile(Sector sector)
  91     {
  92         if (sector == null)
  93         {
  94             String msg = WorldWind.retrieveErrMsg("nullValue.SectorIsNull");
  95             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
  96             throw new IllegalArgumentException(msg);
  97         }
  98
  99         this.sector = sector;
 100         this.level = null;
 101         this.row = 0;
 102         this.column = 0;
 103         this.tileKey = new TileKey(this);
 104         this.path = null;
 105     }
 106
 107     public long getSizeInBytes()
 108     {
 109         // Return just an approximate size
 110         long size = 0;
 111
 112         if (this.sector != null)
 113             size += this.sector.getSizeInBytes();
 114
 115         if (this.path != null)
 116             size += this.getPath().length();
 117
 118         size += 32; // to account for the references and the TileKey size
 119
 120         return size;
 121     }
 122
 123     public String getPath()
 124     {
 125         if (this.path == null)
 126         {
 127             this.path = this.level.getPath() + "/" + this.row + "/" + this.row + "_" + this.column;
 128             if (!this.level.isEmpty())
 129                 path += this.level.getFormatSuffix();
 130         }
 131
 132         return this.path;
 133     }
 134
 135     public final Sector getSector()
 136     {
 137         return sector;
 138     }
 139
 140     public gov.nasa.worldwind.Level getLevel()
 141     {
 142         return level;
 143     }
 144
 145     public final int getLevelNumber()
 146     {
 147         return this.level != null ? this.level.getLevelNumber() : 0;
 148     }
 149
 150     public final String getLevelName()
 151     {
 152         return this.level != null ? this.level.getLevelName() : "";
 153     }
 154
 155     public final int getRow()
 156     {
 157         return row;
 158     }
 159
 160     public final int getColumn()
 161     {
 162         return column;
 163     }
 164
 165     public final String getCacheName()
 166     {
 167         return this.level != null ? this.level.getCacheName() : null;
 168     }
 169
 170     public final String getFormatSuffix()
 171     {
 172         return this.level != null ? this.level.getFormatSuffix() : null;
 173     }
 174
 175     public final TileKey getTileKey()
 176     {
 177         return this.tileKey;
 178     }
 179
 180     public java.net.URL getResourceURL() throws java.net.MalformedURLException
 181     {
 182         return this.level != null ? this.level.getTileResourceURL(this) : null;
 183     }
 184
 185     public String getLabel()
 186     {
 187         StringBuilder sb = new StringBuilder();
 188
 189         sb.append(this.getLevelNumber());
 190         sb.append("(");
 191         sb.append(this.getLevelName());
 192         sb.append(")");
 193         sb.append(", ").append(this.getRow());
 194         sb.append(", ").append(this.getColumn());
 195
 196         return sb.toString();
 197     }
 198
 199     public int compareTo(Tile tile)
 200     {
 201         if (tile == null)
 202         {
 203             String msg = WorldWind.retrieveErrMsg("nullValue.TileIsNull");
 204             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 205             throw new IllegalArgumentException(msg);
 206         }
 207
 208         // No need to compare Sectors or path because they are redundant with row and column
 209         if (tile.getLevelNumber() == this.getLevelNumber() && tile.row == this.row && tile.column == this.column)
 210             return 0;
 211
 212         if (this.getLevelNumber() < tile.getLevelNumber()) // Lower-res levels compare lower than higher-res
 213             return -1;
 214         if (this.getLevelNumber() > tile.getLevelNumber())
 215             return 1;
 216
 217         if (this.row < tile.row)
 218             return -1;
 219         if (this.row > tile.row)
 220             return 1;
 221
 222         if (this.column < tile.column)
 223             return -1;
 224
 225         return 1; // tile.column must be > this.column because equality was tested above
 226     }
 227
 228     @Override
 229     public boolean equals(Object o)
 230     {
 231         // Equality based only on the tile key
 232         if (this == o)
 233             return true;
 234         if (o == null || getClass() != o.getClass())
 235             return false;
 236
 237         final Tile tile = (Tile) o;
 238
 239         return !(tileKey != null ? !tileKey.equals(tile.tileKey) : tile.tileKey != null);
 240     }
 241
 242     @Override
 243     public int hashCode()
 244     {
 245         return (tileKey != null ? tileKey.hashCode() : 0);
 246     }
 247
 248     @Override
 249     public String toString()
 250     {
 251         return this.getPath();
 252     }
 253
 254     /**
 255      * Computes the row index of a latitude in the global tile grid corresponding to a specified grid interval.
 256      *
 257      * @param delta    the grid interval
 258      * @param latitude the latitude for which to compute the row index
 259      * @return the row index of the row containing the specified latitude
 260      * @throws IllegalArgumentException if <code>delta</code> is null or non-positive, or <code>latitude</code> is null,
 261      *                                  greater than positive 90 degrees, or less than  negative 90 degrees
 262      */
 263     public static int computeRow(Angle delta, Angle latitude)
 264     {
 265         if (delta == null || latitude == null)
 266         {
 267             String message = WorldWind.retrieveErrMsg("nullValue.AngleIsNull");
 268             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 269             throw new IllegalArgumentException(message);
 270         }
 271
 272         if (delta.degrees <= 0d)
 273         {
 274             String message = WorldWind.retrieveErrMsg("generic.deltaAngleOutOfRange");
 275             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 276             throw new IllegalArgumentException(message);
 277         }
 278
 279         if (latitude.degrees < -90d || latitude.degrees > 90d)
 280         {
 281             String message = WorldWind.retrieveErrMsg("generic.angleOutOfRange");
 282             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 283             throw new IllegalArgumentException(message);
 284         }
 285
 286         if (latitude.degrees == 90d)
 287             return (int) (180d / delta.degrees) - 1;
 288         else
 289             return (int) ((latitude.degrees + 90d) / delta.degrees);
 290     }
 291
 292     /**
 293      * Computes the column index of a longitude in the global tile grid corresponding to a specified grid interval.
 294      *
 295      * @param delta     the grid interval
 296      * @param longitude the longitude for which to compute the column index
 297      * @return the column index of the column containing the specified latitude
 298      * @throws IllegalArgumentException if <code>delta</code> is null or non-positive, or <code>longitude</code> is
 299      *                                  null, greater than positive 180 degrees, or less than  negative 180 degrees
 300      */
 301     public static int computeColumn(Angle delta, Angle longitude)
 302     {
 303         if (delta == null || longitude == null)
 304         {
 305             String message = WorldWind.retrieveErrMsg("nullValue.AngleIsNull");
 306             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 307             throw new IllegalArgumentException(message);
 308         }
 309
 310         if (delta.degrees <= 0d)
 311         {
 312             String message = WorldWind.retrieveErrMsg("generic.deltaAngleOutOfRange");
 313             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 314             throw new IllegalArgumentException(message);
 315         }
 316
 317         if (longitude.degrees < -180d || longitude.degrees > 180d)
 318         {
 319             String message = WorldWind.retrieveErrMsg("generic.angleOutOfRange");
 320             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 321             throw new IllegalArgumentException(message);
 322         }
 323
 324         if (longitude.degrees == 180d)
 325             return (int) (360d / delta.degrees) - 1;
 326         else
 327             return (int) ((longitude.degrees + 180d) / delta.degrees);
 328     }
 329
 330     /**
 331      * Determines the minimum latitude of a row in the global tile grid corresponding to a specified grid interval.
 332      *
 333      * @param row   the row index of the row in question
 334      * @param delta the grid interval
 335      * @return the minimum latitude of the tile corresponding to the specified row
 336      * @throws IllegalArgumentException if the grid interval (<code>delta</code>) is null or zero or the row index is
 337      *                                  negative.
 338      */
 339     public static Angle computeRowLatitude(int row, Angle delta)
 340     {
 341         if (delta == null)
 342         {
 343             String message = WorldWind.retrieveErrMsg("nullValue.AngleIsNull");
 344             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 345             throw new IllegalArgumentException(message);
 346         }
 347         if (row < 0)
 348         {
 349             String msg = WorldWind.retrieveErrMsg("generic.rowIndexOutOfRange");
 350             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 351             throw new IllegalArgumentException(msg);
 352         }
 353
 354         if (delta.degrees <= 0d)
 355         {
 356             String message = WorldWind.retrieveErrMsg("generic.deltaAngleOutOfRange");
 357             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 358             throw new IllegalArgumentException(message);
 359         }
 360
 361         return Angle.fromDegrees(-90d + delta.degrees * row);
 362     }
 363
 364     /**
 365      * Determines the minimum longitude of a column in the global tile grid corresponding to a specified grid interval.
 366      *
 367      * @param column the row index of the row in question
 368      * @param delta  the grid interval
 369      * @return the minimum longitude of the tile corresponding to the specified column
 370      * @throws IllegalArgumentException if the grid interval (<code>delta</code>) is null or zero or the column index is
 371      *                                  negative.
 372      */
 373     public static Angle computeColumnLongitude(int column, Angle delta)
 374     {
 375         if (delta == null)
 376         {
 377             String message = WorldWind.retrieveErrMsg("nullValue.AngleIsNull");
 378             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 379             throw new IllegalArgumentException(message);
 380         }
 381         if (column < 0)
 382         {
 383             String msg = WorldWind.retrieveErrMsg("generic.columnIndexOutOfRange");
 384             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 385             throw new IllegalArgumentException(msg);
 386         }
 387
 388         if (delta.degrees <= 0d)
 389         {
 390             String message = WorldWind.retrieveErrMsg("generic.deltaAngleOutOfRange");
 391             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 392             throw new IllegalArgumentException(message);
 393         }
 394
 395         return Angle.fromDegrees(-180 + delta.degrees * column);
 396     }
 397
 398     public double getPriority()
 399     {
 400         return priority;
 401     }
 402
 403     public void setPriority(double priority)
 404     {
 405         this.priority = priority;
 406     }
 407 }