gov/nasa/worldwind/geom/Sector.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.geom;
   8
   9 import gov.nasa.worldwind.cache.Cacheable;
  10 import gov.nasa.worldwind.globes.Globe;
  11 import gov.nasa.worldwind.tracks.TrackPoint;
  12 import gov.nasa.worldwind.util.Logging;
  13
  14 /**
  15  * <code>Sector</code> represents a rectangular reqion of latitude and longitude. The region is defined by four angles:
  16  * its minimum and maximum latitude, its minimum and maximum longitude. The angles are assumed to be normalized to +/-
  17  * 90 degrees latitude and +/- 180 degrees longitude. The minimums and maximums are relative to these ranges, e.g., -80
  18  * is less than 20. Behavior of the class is undefined for angles outside these ranges. Normalization is not performed
  19  * on the angles by this class, nor is it verifed by the class' methods. See {@link Angle} for a description of
  20  * specifying angles.
  21  * <p/>
  22  * <code>Sector</code> instances are immutable. </p>
  23  *
  24  * @author Tom Gaskins
  25  * @version $Id: Sector.java 2516 2007-08-07 01:40:17Z tgaskins $
  26  * @see Angle
  27  */
  28 public class Sector implements Cacheable, Comparable<Sector>
  29 {
  30     /**
  31      * A <code>Sector</code> of latitude [-90 degrees, + 90 degrees] and longitude [-180 degrees, + 180 degrees].
  32      */
  33     public static final Sector FULL_SPHERE = new Sector(Angle.NEG90, Angle.POS90, Angle.NEG180, Angle.POS180);
  34     public static final Sector EMPTY_SECTOR = new Sector(Angle.ZERO, Angle.ZERO, Angle.ZERO, Angle.ZERO);
  35
  36     private final Angle minLatitude;
  37     private final Angle maxLatitude;
  38     private final Angle minLongitude;
  39     private final Angle maxLongitude;
  40     private final Angle deltaLat;
  41     private final Angle deltaLon;
  42
  43     /**
  44      * Creates a new <code>Sector</code> and initializes it to the specified angles. The angles are assumed to be
  45      * normalized to +/- 90 degrees latitude and +/- 180 degrees longitude, but this method does not verify that.
  46      *
  47      * @param minLatitude  the sector's minimum latitude in degrees.
  48      * @param maxLatitude  the sector's maximum latitude in degrees.
  49      * @param minLongitude the sector's minimum longitude in degrees.
  50      * @param maxLongitude the sector's maximum longitude in degrees.
  51      * @return the new <code>Sector</code>
  52      */
  53     public static Sector fromDegrees(double minLatitude, double maxLatitude, double minLongitude,
  54         double maxLongitude)
  55     {
  56         return new Sector(Angle.fromDegrees(minLatitude), Angle.fromDegrees(maxLatitude), Angle.fromDegrees(
  57             minLongitude), Angle.fromDegrees(maxLongitude));
  58     }
  59
  60     /**
  61      * Creates a new <code>Sector</code> and initializes it to the specified angles. The angles are assumed to be
  62      * normalized to +/- \u03c0/2 radians latitude and +/- \u03c0 radians longitude, but this method does not verify
  63      * that.
  64      *
  65      * @param minLatitude  the sector's minimum latitude in radians.
  66      * @param maxLatitude  the sector's maximum latitude in radians.
  67      * @param minLongitude the sector's minimum longitude in radians.
  68      * @param maxLongitude the sector's maximum longitude in radians.
  69      * @return the new <code>Sector</code>
  70      */
  71     public static Sector fromRadians(double minLatitude, double maxLatitude, double minLongitude,
  72         double maxLongitude)
  73     {
  74         return new Sector(Angle.fromRadians(minLatitude), Angle.fromRadians(maxLatitude), Angle.fromRadians(
  75             minLongitude), Angle.fromRadians(maxLongitude));
  76     }
  77
  78     public static Sector boundingSector(java.util.Iterator<TrackPoint> positions)
  79     {
  80         if (positions == null)
  81         {
  82             String message = Logging.getMessage("nullValue.TracksPointsIteratorNull");
  83             Logging.logger().severe(message);
  84             throw new IllegalArgumentException(message);
  85         }
  86
  87         if (!positions.hasNext())
  88             return EMPTY_SECTOR;
  89
  90         TrackPoint position = positions.next();
  91         double minLat = position.getLatitude();
  92         double minLon = position.getLongitude();
  93         double maxLat = minLat;
  94         double maxLon = minLon;
  95
  96         while (positions.hasNext())
  97         {
  98             TrackPoint p = positions.next();
  99             double lat = p.getLatitude();
 100             if (lat < minLat)
 101                 minLat = lat;
 102             else if (lat > maxLat)
 103                 maxLat = lat;
 104
 105             double lon = p.getLongitude();
 106             if (lon < minLon)
 107                 minLon = lon;
 108             else if (lon > maxLon)
 109                 maxLon = lon;
 110         }
 111
 112         return Sector.fromDegrees(minLat, maxLat, minLon, maxLon);
 113     }
 114
 115     public static Sector boundingSector(Iterable<LatLon> positions)
 116     {
 117         if (positions == null)
 118         {
 119             String message = Logging.getMessage("nullValue.PositionsListIsNull");
 120             Logging.logger().severe(message);
 121             throw new IllegalArgumentException(message);
 122         }
 123
 124         double minLat = Angle.POS90.getDegrees();
 125         double minLon = Angle.POS180.getDegrees();
 126         double maxLat = Angle.NEG180.getDegrees();
 127         double maxLon = Angle.NEG180.getDegrees();
 128
 129         for (LatLon p : positions)
 130         {
 131             double lat = p.getLatitude().getDegrees();
 132             if (lat < minLat)
 133                 minLat = lat;
 134             if (lat > maxLat)
 135                 maxLat = lat;
 136
 137             double lon = p.getLongitude().getDegrees();
 138             if (lon < minLon)
 139                 minLon = lon;
 140             if (lon > maxLon)
 141                 maxLon = lon;
 142         }
 143
 144         if (minLat == maxLat && minLon == maxLon)
 145             return EMPTY_SECTOR;
 146
 147         return Sector.fromDegrees(minLat, maxLat, minLon, maxLon);
 148     }
 149
 150     public static Sector boundingSector(Position pA, Position pB)
 151     {
 152         if (pA == null || pB == null)
 153         {
 154             String message = Logging.getMessage("nullValue.PositionsListIsNull");
 155             Logging.logger().severe(message);
 156             throw new IllegalArgumentException(message);
 157         }
 158
 159         double minLat = pA.getLatitude().degrees;
 160         double minLon = pA.getLongitude().degrees;
 161         double maxLat = pA.getLatitude().degrees;
 162         double maxLon = pA.getLongitude().degrees;
 163
 164         if (pB.getLatitude().degrees < minLat)
 165             minLat = pB.getLatitude().degrees;
 166         else if (pB.getLatitude().degrees > maxLat)
 167             maxLat = pB.getLatitude().degrees;
 168
 169         if (pB.getLongitude().degrees < minLon)
 170             minLon = pB.getLongitude().degrees;
 171         else if (pB.getLongitude().degrees > maxLon)
 172             maxLon = pB.getLongitude().degrees;
 173
 174         if (minLat == maxLat && minLon == maxLon)
 175             return EMPTY_SECTOR;
 176
 177         return Sector.fromDegrees(minLat, maxLat, minLon, maxLon);
 178     }
 179
 180     /**
 181      * Creates a new <code>Sector</code> and initializes it to the specified angles. The angles are assumed to be
 182      * normalized to +/- 90 degrees latitude and +/- 180 degrees longitude, but this method does not verify that.
 183      *
 184      * @param minLatitude  the sector's minimum latitude.
 185      * @param maxLatitude  the sector's maximum latitude.
 186      * @param minLongitude the sector's minimum longitude.
 187      * @param maxLongitude the sector's maximum longitude.
 188      * @throws IllegalArgumentException if any of the angles are null
 189      */
 190     public Sector(Angle minLatitude, Angle maxLatitude, Angle minLongitude, Angle maxLongitude)
 191     {
 192         if (minLatitude == null || maxLatitude == null || minLongitude == null || maxLongitude == null)
 193         {
 194             String message = Logging.getMessage("nullValue.InputAnglesNull");
 195             Logging.logger().severe(message);
 196             throw new IllegalArgumentException(message);
 197         }
 198
 199         this.minLatitude = minLatitude;
 200         this.maxLatitude = maxLatitude;
 201         this.minLongitude = minLongitude;
 202         this.maxLongitude = maxLongitude;
 203         this.deltaLat = Angle.fromDegrees(this.maxLatitude.degrees - this.minLatitude.degrees);
 204         this.deltaLon = Angle.fromDegrees(this.maxLongitude.degrees - this.minLongitude.degrees);
 205     }
 206
 207     public Sector(Sector sector)
 208     {
 209         if (sector == null)
 210         {
 211             String message = Logging.getMessage("nullValue.SectorIsNull");
 212             Logging.logger().severe(message);
 213             throw new IllegalArgumentException(message);
 214         }
 215
 216         this.minLatitude = new Angle(sector.getMinLatitude());
 217         this.maxLatitude = new Angle(sector.getMaxLatitude());
 218         this.minLongitude = new Angle(sector.getMinLongitude());
 219         this.maxLongitude = new Angle(sector.getMaxLongitude());
 220         this.deltaLat = Angle.fromDegrees(this.maxLatitude.degrees - this.minLatitude.degrees);
 221         this.deltaLon = Angle.fromDegrees(this.maxLongitude.degrees - this.minLongitude.degrees);
 222     }
 223
 224     /**
 225      * Returns the sector's minimum latitude.
 226      *
 227      * @return The sector's minimum latitude.
 228      */
 229     public final Angle getMinLatitude()
 230     {
 231         return minLatitude;
 232     }
 233
 234     /**
 235      * Returns the sector's minimum longitude.
 236      *
 237      * @return The sector's minimum longitude.
 238      */
 239     public final Angle getMinLongitude()
 240     {
 241         return minLongitude;
 242     }
 243
 244     /**
 245      * Returns the sector's maximum latitude.
 246      *
 247      * @return The sector's maximum latitude.
 248      */
 249     public final Angle getMaxLatitude()
 250     {
 251         return maxLatitude;
 252     }
 253
 254     /**
 255      * Returns the sector's maximum longitude.
 256      *
 257      * @return The sector's maximum longitude.
 258      */
 259     public final Angle getMaxLongitude()
 260     {
 261         return maxLongitude;
 262     }
 263
 264     /**
 265      * Returns the angular difference between the sector's minimum and maximum latitudes: max - min
 266      *
 267      * @return The angular difference between the sector's minimum and maximum latitudes.
 268      */
 269     public final Angle getDeltaLat()
 270     {
 271         return this.deltaLat;//Angle.fromDegrees(this.maxLatitude.degrees - this.minLatitude.degrees);
 272     }
 273
 274     public final double getDeltaLatDegrees()
 275     {
 276         return this.deltaLat.degrees;//this.maxLatitude.degrees - this.minLatitude.degrees;
 277     }
 278
 279     public final double getDeltaLatRadians()
 280     {
 281         return this.deltaLat.radians;//this.maxLatitude.radians - this.minLatitude.radians;
 282     }
 283
 284     /**
 285      * Returns the angular difference between the sector's minimum and maximum longitudes: max - min.
 286      *
 287      * @return The angular difference between the sector's minimum and maximum longitudes
 288      */
 289     public final Angle getDeltaLon()
 290     {
 291         return this.deltaLon;//Angle.fromDegrees(this.maxLongitude.degrees - this.minLongitude.degrees);
 292     }
 293
 294     public final double getDeltaLonDegrees()
 295     {
 296         return this.deltaLon.degrees;//this.maxLongitude.degrees - this.minLongitude.degrees;
 297     }
 298
 299     public final double getDeltaLonRadians()
 300     {
 301         return this.deltaLon.radians;//this.maxLongitude.radians - this.minLongitude.radians;
 302     }
 303
 304     /**
 305      * Returns the latitude and longitude of the sector's angular center: (minimum latitude + maximum latitude) / 2,
 306      * (minimum longitude + maximum longitude) / 2.
 307      *
 308      * @return The latitude and longitude of the sector's angular center
 309      */
 310     public final LatLon getCentroid()
 311     {
 312         Angle la = Angle.fromDegrees(0.5 * (this.getMaxLatitude().degrees + this.getMinLatitude().degrees));
 313         Angle lo = Angle.fromDegrees(0.5 * (this.getMaxLongitude().degrees + this.getMinLongitude().degrees));
 314         return new LatLon(la, lo);
 315     }
 316
 317     public Vec4 computeCenterPoint(Globe globe)
 318     {
 319         if (globe == null)
 320         {
 321             String msg = Logging.getMessage("nullValue.GlobeIsNull");
 322             Logging.logger().severe(msg);
 323             throw new IllegalArgumentException(msg);
 324         }
 325
 326         double lat = 0.5 * (this.minLatitude.degrees + this.maxLatitude.degrees);
 327         double lon = 0.5 * (this.minLongitude.degrees + this.maxLongitude.degrees);
 328
 329         Angle cLat = Angle.fromDegrees(lat);
 330         Angle cLon = Angle.fromDegrees(lon);
 331         return globe.computePointFromPosition(cLat, cLon, globe.getElevation(cLat, cLon));
 332     }
 333
 334     public Vec4[] computeCornerPoints(Globe globe)
 335     {
 336         if (globe == null)
 337         {
 338             String msg = Logging.getMessage("nullValue.GlobeIsNull");
 339             Logging.logger().severe(msg);
 340             throw new IllegalArgumentException(msg);
 341         }
 342         Vec4[] corners = new Vec4[4];
 343
 344         Angle minLat = this.minLatitude;
 345         Angle maxLat = this.maxLatitude;
 346         Angle minLon = this.minLongitude;
 347         Angle maxLon = this.maxLongitude;
 348
 349         corners[0] = globe.computePointFromPosition(minLat, minLon, globe.getElevation(minLat, minLon));
 350         corners[1] = globe.computePointFromPosition(minLat, maxLon, globe.getElevation(minLat, maxLon));
 351         corners[2] = globe.computePointFromPosition(maxLat, maxLon, globe.getElevation(maxLat, maxLon));
 352         corners[3] = globe.computePointFromPosition(maxLat, minLon, globe.getElevation(maxLat, minLon));
 353
 354         return corners;
 355     }
 356
 357     /**
 358      * Returns a sphere that minimally surrounds the sector at a specified vertical exaggeration.
 359      *
 360      * @param globe                the globe the sector is associated with
 361      * @param verticalExaggeration the vertical exaggeration to apply to the globe's elevations when computing the
 362      *                             sphere.
 363      * @param sector               the sector to return the bounding sphere for.
 364      * @return The minimal bounding sphere in Cartesian coordinates.
 365      * @throws IllegalArgumentException if <code>globe</code> or <code>sector</code> is null
 366      */
 367     static public Extent computeBoundingSphere(Globe globe, double verticalExaggeration, Sector sector)
 368     {
 369         if (globe == null)
 370         {
 371             String msg = Logging.getMessage("nullValue.GlobeIsNull");
 372             Logging.logger().severe(msg);
 373             throw new IllegalArgumentException(msg);
 374         }
 375         if (sector == null)
 376         {
 377             String msg = Logging.getMessage("nullValue.SectorIsNull");
 378             Logging.logger().severe(msg);
 379             throw new IllegalArgumentException(msg);
 380         }
 381
 382         LatLon center = sector.getCentroid();
 383         double maxHeight = globe.getMaxElevation() * verticalExaggeration;
 384         double minHeight = 0;//globe.getMinElevation() * verticalExaggeration;
 385
 386         Vec4[] points = new Vec4[9];
 387         points[0] = globe.computePointFromPosition(center.getLatitude(), center.getLongitude(), maxHeight);
 388         points[1] = globe.computePointFromPosition(sector.getMaxLatitude(), sector.getMinLongitude(), maxHeight);
 389         points[2] = globe.computePointFromPosition(sector.getMinLatitude(), sector.getMaxLongitude(), maxHeight);
 390         points[3] = globe.computePointFromPosition(sector.getMinLatitude(), sector.getMinLongitude(), maxHeight);
 391         points[4] = globe.computePointFromPosition(sector.getMaxLatitude(), sector.getMaxLongitude(), maxHeight);
 392         points[5] = globe.computePointFromPosition(sector.getMaxLatitude(), sector.getMinLongitude(), minHeight);
 393         points[6] = globe.computePointFromPosition(sector.getMinLatitude(), sector.getMaxLongitude(), minHeight);
 394         points[7] = globe.computePointFromPosition(sector.getMinLatitude(), sector.getMinLongitude(), minHeight);
 395         points[8] = globe.computePointFromPosition(sector.getMaxLatitude(), sector.getMaxLongitude(), minHeight);
 396
 397         return Sphere.createBoundingSphere(points);
 398     }
 399
 400     /**
 401      * Returns a cylinder that minimally surrounds the sector at a specified vertical exaggeration.
 402      *
 403      * @param globe                the globe the sector is associated with.
 404      * @param verticalExaggeration the vertical exaggeration to apply to the globe's elevations when computing the
 405      *                             cylinder.
 406      * @param sector               the sector to return the bounding cylinder for.
 407      * @return The minimal bounding cylinder in Cartesian coordinates.
 408      * @throws IllegalArgumentException if <code>globe</code> or <code>sector</code> is null
 409      */
 410     static public Cylinder computeBoundingCylinder(Globe globe, double verticalExaggeration, Sector sector)
 411     {
 412         if (globe == null)
 413         {
 414             String msg = Logging.getMessage("nullValue.GlobeIsNull");
 415             Logging.logger().severe(msg);
 416             throw new IllegalArgumentException(msg);
 417         }
 418         if (sector == null)
 419         {
 420             String msg = Logging.getMessage("nullValue.SectorIsNull");
 421             Logging.logger().severe(msg);
 422             throw new IllegalArgumentException(msg);
 423         }
 424
 425         // Compute the center points of the bounding cylinder's top and bottom planes.
 426         LatLon center = sector.getCentroid();
 427         double maxHeight = globe.getMaxElevation() * verticalExaggeration;
 428         double minHeight = 0;//globe.getMinElevation() * verticalExaggeration;
 429         Vec4 centroidTop = globe.computePointFromPosition(center.getLatitude(), center.getLongitude(), maxHeight);
 430         Vec4 lowPoint = globe.computePointFromPosition(sector.getMinLatitude(), sector.getMinLongitude(), minHeight);
 431         Vec4 axis = centroidTop.normalize3();
 432         double lowDistance = axis.dot3(lowPoint);
 433         Vec4 centroidBot = axis.multiply3(lowDistance);
 434
 435         // Compute radius of circumscribing circle around general quadrilateral.
 436         Vec4 northwest = globe.computePointFromPosition(sector.getMaxLatitude(), sector.getMinLongitude(), maxHeight);
 437         Vec4 southeast = globe.computePointFromPosition(sector.getMinLatitude(), sector.getMaxLongitude(), maxHeight);
 438         Vec4 southwest = globe.computePointFromPosition(sector.getMinLatitude(), sector.getMinLongitude(), maxHeight);
 439         Vec4 northeast = globe.computePointFromPosition(sector.getMaxLatitude(), sector.getMaxLongitude(), maxHeight);
 440         double a = southwest.distanceTo3(southeast);
 441         double b = southeast.distanceTo3(northeast);
 442         double c = northeast.distanceTo3(northwest);
 443         double d = northwest.distanceTo3(southwest);
 444         double s = 0.5 * (a + b + c + d);
 445         double area = Math.sqrt((s - a) * (s - b) * (s - c) * (s - d));
 446         double radius = Math.sqrt((a * b + c * d) * (a * d + b * c) * (a * c + b * d)) / (4d * area);
 447
 448         return new Cylinder(centroidBot, centroidTop, radius);
 449     }
 450
 451     public final boolean contains(Angle latitude, Angle longitude)
 452     {
 453         if (latitude == null || longitude == null)
 454         {
 455             String message = Logging.getMessage("nullValue.LatLonIsNull");
 456             Logging.logger().severe(message);
 457             throw new IllegalArgumentException(message);
 458         }
 459
 460         return latitude.degrees >= this.minLatitude.degrees
 461             && latitude.degrees <= this.maxLatitude.degrees
 462             && longitude.degrees >= this.minLongitude.degrees
 463             && longitude.degrees <= this.maxLongitude.degrees;
 464     }
 465
 466     /**
 467      * Determines whether a latitude/longitude position is within the sector. The sector's angles are assumed to be
 468      * normalized to +/- 90 degrees latitude and +/- 180 degrees longitude. The result of the operation is undefined if
 469      * they are not.
 470      *
 471      * @param latLon the position to test, with angles normalized to +/- &#960 latitude and +/- 2&#960 longitude.
 472      * @return <code>true</code> if the position is within the sector, <code>false</code> otherwise.
 473      * @throws IllegalArgumentException if <code>latlon</code> is null.
 474      */
 475     public final boolean contains(LatLon latLon)
 476     {
 477         if (latLon == null)
 478         {
 479             String message = Logging.getMessage("nullValue.LatLonIsNull");
 480             Logging.logger().severe(message);
 481             throw new IllegalArgumentException(message);
 482         }
 483
 484         return this.contains(latLon.getLatitude(), latLon.getLongitude());
 485     }
 486
 487     /**
 488      * Determines whether a latitude/longitude postion expressed in radians is within the sector. The sector's angles
 489      * are assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude. The result of the
 490      * operation is undefined if they are not.
 491      *
 492      * @param radiansLatitude  the latitude in radians of the position to test, normalized +/- &#960.
 493      * @param radiansLongitude the longitude in radians of the position to test, normalized +/- 2&#960.
 494      * @return <code>true</code> if the position is within the sector, <code>false</code> otherwise.
 495      */
 496     public final boolean containsRadians(double radiansLatitude, double radiansLongitude)
 497     {
 498         return radiansLatitude >= this.minLatitude.radians && radiansLatitude <= this.maxLatitude.radians
 499             && radiansLongitude >= this.minLongitude.radians && radiansLongitude <= this.maxLongitude.radians;
 500     }
 501
 502     public final boolean containsDegrees(double degreesLatitude, double degreesLongitude)
 503     {
 504         return degreesLatitude >= this.minLatitude.degrees && degreesLatitude <= this.maxLatitude.degrees
 505             && degreesLongitude >= this.minLongitude.degrees && degreesLongitude <= this.maxLongitude.degrees;
 506     }
 507
 508     /**
 509      * Determines whether this sector intersects another sector's range of latitude and longitude. The sector's angles
 510      * are assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude. The result of the
 511      * operation is undefined if they are not.
 512      *
 513      * @param that the sector to test for intersection.
 514      * @return <code>true</code> if the sectors intersect, otherwise <code>false</code>.
 515      */
 516     public boolean intersects(Sector that)
 517     {
 518         if (that == null)
 519             return false;
 520
 521         // Assumes normalized angles -- [-180, 180], [-90, 90] // TODO: have Angle normalize values when set
 522         if (that.maxLongitude.degrees < this.minLongitude.degrees)
 523             return false;
 524         if (that.minLongitude.degrees > this.maxLongitude.degrees)
 525             return false;
 526         if (that.maxLatitude.degrees < this.minLatitude.degrees)
 527             return false;
 528         //noinspection RedundantIfStatement
 529         if (that.minLatitude.degrees > this.maxLatitude.degrees)
 530             return false;
 531
 532         return true;
 533     }
 534
 535     /**
 536      * Returns a new sector whose angles are the extremes of the this sector and another. The new sector's minimum
 537      * latitude and longitude will be the minimum of the two sectors. The new sector's maximum latitude and longitude
 538      * will be the maximum of the two sectors. The sectors are assumed to be normalized to +/- 90 degrees latitude and
 539      * +/- 180 degrees longitude. The result of the operation is undefined if they are not.
 540      *
 541      * @param that the sector to join with <code>this</code>.
 542      * @return A new sector formed from the extremes of the two sectors, or <code>this</code> if the incoming sector is
 543      *         <code>null</code>.
 544      */
 545     public final Sector union(Sector that)
 546     {
 547         if (that == null)
 548             return this;
 549
 550         Angle minLat = this.minLatitude;
 551         Angle maxLat = this.maxLatitude;
 552         Angle minLon = this.minLongitude;
 553         Angle maxLon = this.maxLongitude;
 554
 555         if (that.minLatitude.degrees < this.minLatitude.degrees)
 556             minLat = that.minLatitude;
 557         if (that.maxLatitude.degrees > this.maxLatitude.degrees)
 558             maxLat = that.maxLatitude;
 559         if (that.minLongitude.degrees < this.minLongitude.degrees)
 560             minLon = that.minLongitude;
 561         if (that.maxLongitude.degrees > this.maxLongitude.degrees)
 562             maxLon = that.maxLongitude;
 563
 564         return new Sector(minLat, maxLat, minLon, maxLon);
 565     }
 566
 567     public final Sector union(Angle latitude, Angle longitude)
 568     {
 569         if (latitude == null || longitude == null)
 570             return this;
 571
 572         Angle minLat = this.minLatitude;
 573         Angle maxLat = this.maxLatitude;
 574         Angle minLon = this.minLongitude;
 575         Angle maxLon = this.maxLongitude;
 576
 577         if (latitude.degrees < this.minLatitude.degrees)
 578             minLat = latitude;
 579         if (latitude.degrees > this.maxLatitude.degrees)
 580             maxLat = latitude;
 581         if (longitude.degrees < this.minLongitude.degrees)
 582             minLon = longitude;
 583         if (longitude.degrees > this.maxLongitude.degrees)
 584             maxLon = longitude;
 585
 586         return new Sector(minLat, maxLat, minLon, maxLon);
 587     }
 588
 589     public static Sector union(Sector sectorA, Sector sectorB)
 590     {
 591         if (sectorA == null || sectorB == null)
 592         {
 593             if (sectorA == sectorB)
 594                 return null; // TODO: throw exception
 595
 596             return sectorB == null ? sectorA : sectorB;
 597         }
 598
 599         return sectorA.union(sectorB);
 600     }
 601
 602     public final Sector intersection(Sector that)
 603     {
 604         if (that == null)
 605             return this;
 606
 607         Angle minLat, maxLat;
 608         minLat = (this.minLatitude.degrees > that.minLatitude.degrees) ? this.minLatitude : that.minLatitude;
 609         maxLat = (this.maxLatitude.degrees < that.maxLatitude.degrees) ? this.maxLatitude : that.maxLatitude;
 610         if (minLat.degrees > maxLat.degrees)
 611             return null;
 612
 613         Angle minLon, maxLon;
 614         minLon = (this.minLongitude.degrees > that.minLongitude.degrees) ? this.minLongitude : that.minLongitude;
 615         maxLon = (this.maxLongitude.degrees < that.maxLongitude.degrees) ? this.maxLongitude : that.maxLongitude;
 616         if (minLon.degrees > maxLon.degrees)
 617             return null;
 618
 619         return new Sector(minLat, maxLat, minLon, maxLon);
 620     }
 621
 622     public final Sector intersection(Angle latitude, Angle longitude)
 623     {
 624         if (latitude == null || longitude == null)
 625             return this;
 626
 627         if (!this.contains(latitude, longitude))
 628             return null;
 629         return new Sector(latitude, latitude, longitude, longitude);
 630     }
 631
 632     public final Sector[] subdivide()
 633     {
 634         Angle midLat = Angle.average(this.minLatitude, this.maxLatitude);
 635         Angle midLon = Angle.average(this.minLongitude, this.maxLongitude);
 636
 637         Sector[] sectors = new Sector[4];
 638         sectors[0] = new Sector(this.minLatitude, midLat, this.minLongitude, midLon);
 639         sectors[1] = new Sector(this.minLatitude, midLat, midLon, this.maxLongitude);
 640         sectors[2] = new Sector(midLat, this.maxLatitude, this.minLongitude, midLon);
 641         sectors[3] = new Sector(midLat, this.maxLatitude, midLon, this.maxLongitude);
 642
 643         return sectors;
 644     }
 645
 646     /**
 647      * Returns a string indicating the sector's angles.
 648      *
 649      * @return A string indicating the sector's angles.
 650      */
 651     @Override
 652     public String toString()
 653     {
 654         java.lang.StringBuffer sb = new java.lang.StringBuffer();
 655         sb.append("(");
 656         sb.append(this.minLatitude.toString());
 657         sb.append(", ");
 658         sb.append(this.minLongitude.toString());
 659         sb.append(")");
 660
 661         sb.append(", ");
 662
 663         sb.append("(");
 664         sb.append(this.maxLatitude.toString());
 665         sb.append(", ");
 666         sb.append(this.maxLongitude.toString());
 667         sb.append(")");
 668
 669         return sb.toString();
 670     }
 671
 672     /**
 673      * Retrieve the size of this object in bytes. This implementation returns an exact value of the object's size.
 674      *
 675      * @return the size of this object in bytes
 676      */
 677     public long getSizeInBytes()
 678     {
 679         return 4 * minLatitude.getSizeInBytes();  // 4 angles
 680     }
 681
 682     /**
 683      * Compares this sector to a specified sector according to their minimum latitude, minimum longitude, maximum
 684      * latitude, and maximum longitude, respectively.
 685      *
 686      * @param that the <code>Sector</code> to compareTo with <code>this</code>.
 687      * @return -1 if this sector compares less than that specified, 0 if they're equal, and 1 if it compares greater.
 688      * @throws IllegalArgumentException if <code>that</code> is null
 689      */
 690     public int compareTo(Sector that)
 691     {
 692         if (that == null)
 693         {
 694             String msg = Logging.getMessage("nullValue.SectorIsNull");
 695             Logging.logger().severe(msg);
 696             throw new IllegalArgumentException(msg);
 697         }
 698
 699         if (this.getMinLatitude().compareTo(that.getMinLatitude()) < 0)
 700             return -1;
 701
 702         if (this.getMinLatitude().compareTo(that.getMinLatitude()) > 0)
 703             return 1;
 704
 705         if (this.getMinLongitude().compareTo(that.getMinLongitude()) < 0)
 706             return -1;
 707
 708         if (this.getMinLongitude().compareTo(that.getMinLongitude()) > 0)
 709             return 1;
 710
 711         if (this.getMaxLatitude().compareTo(that.getMaxLatitude()) < 0)
 712             return -1;
 713
 714         if (this.getMaxLatitude().compareTo(that.getMaxLatitude()) > 0)
 715             return 1;
 716
 717         if (this.getMaxLongitude().compareTo(that.getMaxLongitude()) < 0)
 718             return -1;
 719
 720         if (this.getMaxLongitude().compareTo(that.getMaxLongitude()) > 0)
 721             return 1;
 722
 723         return 0;
 724     }
 725
 726     /**
 727      * Tests the equality of the sectors' angles. Sectors are equal if all of their corresponding angles are equal.
 728      *
 729      * @param o the sector to compareTo with <code>this</code>.
 730      * @return <code>true</code> if the four corresponding angles of each sector are equal, <code>false</code>
 731      *         otherwise.
 732      */
 733     @Override
 734     public boolean equals(Object o)
 735     {
 736         if (this == o)
 737             return true;
 738         if (o == null || getClass() != o.getClass())
 739             return false;
 740
 741         final gov.nasa.worldwind.geom.Sector sector = (gov.nasa.worldwind.geom.Sector) o;
 742
 743         if (!maxLatitude.equals(sector.maxLatitude))
 744             return false;
 745         if (!maxLongitude.equals(sector.maxLongitude))
 746             return false;
 747         if (!minLatitude.equals(sector.minLatitude))
 748             return false;
 749         //noinspection RedundantIfStatement
 750         if (!minLongitude.equals(sector.minLongitude))
 751             return false;
 752
 753         return true;
 754     }
 755
 756     /**
 757      * Computes a hash code from the sector's four angles.
 758      *
 759      * @return a hash code incorporating the sector's four angles.
 760      */
 761     @Override
 762     public int hashCode()
 763     {
 764         int result;
 765         result = minLatitude.hashCode();
 766         result = 29 * result + maxLatitude.hashCode();
 767         result = 29 * result + minLongitude.hashCode();
 768         result = 29 * result + maxLongitude.hashCode();
 769         return result;
 770     }
 771 }