Overview | Package | Class | Use | Tree | Index | Help
| NASA World Wind
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## gov.nasa.worldwind.geom
Class Sector

    java.lang.Object
      gov.nasa.worldwind.geom.Sector

All Implemented Interfaces:
  Cacheable, Comparable<Sector>

    public class Sector

extends Object
implements Cacheable, Comparable<Sector>

`Sector` represents a rectangular reqion of latitude and longitude. The region is defined by four angles: its minimum and maximum latitude, its minimum and maximum longitude. The angles are assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude. The minimums and maximums are relative to these ranges, e.g., -80 is less than 20. Behavior of the class is undefined for angles outside these ranges. Normalization is not performed on the angles by this class, nor is it verifed by the class' methods. See `Angle` for a description of specifying angles.

`Sector` instances are immutable.

See Also:
  `Angle`

Field Summary
`static Sector` | `EMPTY_SECTOR`
`static Sector` | `FULL_SPHERE` A `Sector` of latitude [-90 degrees, + 90 degrees] and longitude [-180 degrees, + 180 degrees].

Constructor Summary
`Sector(Angle minLatitude, Angle maxLatitude, Angle minLongitude, Angle maxLongitude)` Creates a new `Sector` and initializes it to the specified angles.
`Sector(Sector sector)`

Method Summary
`static Sector` | `boundingSector(Iterable<LatLon> positions)`
`static Sector` | `boundingSector(Iterator<TrackPoint> positions)`
`int` | `compareTo(Sector that)` Compares this sector to a specified sector according to their minimum latitude, minimum longitude, maximum latitude, and maximum longitude, respectively.
`static Cylinder` | `computeBoundingCylinder(Globe globe, double verticalExaggeration, Sector sector)` Returns a cylinder that minimally surrounds the sector at a specified vertical exaggeration.
`static Extent` | `computeBoundingSphere(Globe globe, double verticalExaggeration, Sector sector)` Returns a sphere that minimally surrounds the sector at a specified vertical exaggeration.
`Point` | `computeCenterPoint(Globe globe)`
`Point[]` | `computeCornerPoints(Globe globe)`
`boolean` | `contains(Angle latitude, Angle longitude)`
`boolean` | `contains(LatLon latLon)` Determines whether a latitude/longitude position is within the sector.
`boolean` | `containsDegrees(double degreesLatitude, double degreesLongitude)`
`boolean` | `containsRadians(double radiansLatitude, double radiansLongitude)` Determines whether a latitude/longitude postion expressed in radians is within the sector.
`boolean` | `equals(Object o)` Tests the equality of the sectors' angles.
`static Sector` | `fromDegrees(double minLatitude, double maxLatitude, double minLongitude, double maxLongitude)` Creates a new `Sector` and initializes it to the specified angles.
`static Sector` | `fromRadians(double minLatitude, double maxLatitude, double minLongitude, double maxLongitude)` Creates a new `Sector` and initializes it to the specified angles.
`LatLon` | `getCentroid()` Returns the latitude and longitude of the sector's angular center: (minimum latitude + maximum latitude) / 2, (minimum longitude + maximum longitude) / 2.
`Angle` | `getDeltaLat()` Returns the angular difference between the sector's minimum and maximum latitudes: max - min
`double` | `getDeltaLatDegrees()`
`double` | `getDeltaLatRadians()`
`Angle` | `getDeltaLon()` Returns the angular difference between the sector's minimum and maximum longitudes: max - min.
`double` | `getDeltaLonDegrees()`
`double` | `getDeltaLonRadians()`
`Angle` | `getMaxLatitude()` Returns the sector's maximum latitude.
`Angle` | `getMaxLongitude()` Returns the sector's maximum longitude.
`Angle` | `getMinLatitude()` Returns the sector's minimum latitude.
`Angle` | `getMinLongitude()` Returns the sector's minimum longitude.
`long` | `getSizeInBytes()` Retrieve the size of this object in bytes.
`int` | `hashCode()` Computes a hash code from the sector's four angles.
`Sector` | `intersection(Angle latitude, Angle longitude)`
`Sector` | `intersection(Sector that)`
`boolean` | `intersects(Sector that)` Determines whether this sector intersects another sector's range of latitude and longitude.
`Sector[]` | `subdivide()`
`String` | `toString()` Returns a string indicating the sector's angles.
`Sector` | `union(Angle latitude, Angle longitude)`
`Sector` | `union(Sector that)` Returns a new sector whose angles are the extremes of the this sector and another.

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### EMPTY_SECTOR

    public static final Sector EMPTY_SECTOR

### FULL_SPHERE

    public static final Sector FULL_SPHERE

  A `Sector` of latitude [-90 degrees, + 90 degrees] and longitude [-180 degrees, + 180 degrees].

Constructor Detail

### Sector

    public Sector(Angle minLatitude,
                  Angle maxLatitude,
                  Angle minLongitude,
                  Angle maxLongitude)

  Creates a new `Sector` and initializes it to the specified angles. The angles are assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude, but this method does not verify that.

  Parameters:
    `minLatitude` - the sector's minimum latitude.
    `maxLatitude` - the sector's maximum latitude.
    `minLongitude` - the sector's minimum longitude.
    `maxLongitude` - the sector's maximum longitude.
  Throws:
    `IllegalArgumentException` - if any of the angles are null

### Sector

    public Sector(Sector sector)

Method Detail

### boundingSector

    public static Sector boundingSector(Iterable<LatLon> positions)

### boundingSector

    public static Sector boundingSector(Iterator<TrackPoint> positions)

### compareTo

    public int compareTo(Sector that)

  Compares this sector to a specified sector according to their minimum latitude, minimum longitude, maximum latitude, and maximum longitude, respectively.

  Specified by:
    `compareTo` in interface `Comparable<Sector>`
  Parameters:
    `that` - the `Sector` to compareTo with `this`.
  Returns:
    -1 if this sector compares less than that specified, 0 if they're equal, and 1 if it compares greater.
  Throws:
    `IllegalArgumentException` - if `that` is null

### computeBoundingCylinder

    public static Cylinder computeBoundingCylinder(Globe globe,
                                                   double verticalExaggeration,
                                                   Sector sector)

  Returns a cylinder that minimally surrounds the sector at a specified vertical exaggeration.

  Parameters:
    `globe` - the globe the sector is associated with.
    `verticalExaggeration` - the vertical exaggeration to apply to the globe's elevations when computing the cylinder.
    `sector` - the sector to return the bounding cylinder for.
  Returns:
    The minimal bounding cylinder in Cartesian coordinates.
  Throws:
    `IllegalArgumentException` - if `globe` or `sector` is null

### computeBoundingSphere

    public static Extent computeBoundingSphere(Globe globe,
                                               double verticalExaggeration,
                                               Sector sector)

  Returns a sphere that minimally surrounds the sector at a specified vertical exaggeration.

  Parameters:
    `globe` - the globe the sector is associated with
    `verticalExaggeration` - the vertical exaggeration to apply to the globe's elevations when computing the sphere.
    `sector` - the sector to return the bounding sphere for.
  Returns:
    The minimal bounding sphere in Cartesian coordinates.
  Throws:
    `IllegalArgumentException` - if `globe` or `sector` is null

### computeCenterPoint

    public Point computeCenterPoint(Globe globe)

### computeCornerPoints

    public Point[] computeCornerPoints(Globe globe)

### contains

    public final boolean contains(Angle latitude,
                                  Angle longitude)

### contains

    public final boolean contains(LatLon latLon)

  Determines whether a latitude/longitude position is within the sector. The sector's angles are assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude. The result of the operation is undefined if they are not.

  Parameters:
    `latLon` - the position to test, with angles normalized to +/- π latitude and +/- 2π longitude.
  Returns:
    `true` if the position is within the sector, `false` otherwise.
  Throws:
    `IllegalArgumentException` - if `latlon` is null.

### containsDegrees

    public final boolean containsDegrees(double degreesLatitude,
                                         double degreesLongitude)

### containsRadians

    public final boolean containsRadians(double radiansLatitude,
                                         double radiansLongitude)

  Determines whether a latitude/longitude postion expressed in radians is within the sector. The sector's angles are assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude. The result of the operation is undefined if they are not.

  Parameters:
    `radiansLatitude` - the latitude in radians of the position to test, normalized +/- π.
    `radiansLongitude` - the longitude in radians of the position to test, normalized +/- 2π.
  Returns:
    `true` if the position is within the sector, `false` otherwise.

### equals

    public boolean equals(Object o)

  Tests the equality of the sectors' angles. Sectors are equal if all of their corresponding angles are equal.

  Overrides:
    `equals` in class `Object`
  Parameters:
    `o` - the sector to compareTo with `this`.
  Returns:
    `true` if the four corresponding angles of each sector are equal, `false` otherwise.

### fromDegrees

    public static Sector fromDegrees(double minLatitude,
                                     double maxLatitude,
                                     double minLongitude,
                                     double maxLongitude)

  Creates a new `Sector` and initializes it to the specified angles. The angles are assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude, but this method does not verify that.

  Parameters:
    `minLatitude` - the sector's minimum latitude in degrees.
    `maxLatitude` - the sector's maximum latitude in degrees.
    `minLongitude` - the sector's minimum longitude in degrees.
    `maxLongitude` - the sector's maximum longitude in degrees.
  Returns:
    the new `Sector`

### fromRadians

    public static Sector fromRadians(double minLatitude,
                                     double maxLatitude,
                                     double minLongitude,
                                     double maxLongitude)

  Creates a new `Sector` and initializes it to the specified angles. The angles are assumed to be normalized to +/- ¹/2 radians latitude and +/- ¹ radians longitude, but this method does not verify that.

  Parameters:
    `minLatitude` - the sector's minimum latitude in radians.
    `maxLatitude` - the sector's maximum latitude in radians.
    `minLongitude` - the sector's minimum longitude in radians.
    `maxLongitude` - the sector's maximum longitude in radians.
  Returns:
    the new `Sector`

### getCentroid

    public final LatLon getCentroid()

  Returns the latitude and longitude of the sector's angular center: (minimum latitude + maximum latitude) / 2, (minimum longitude + maximum longitude) / 2.

  Returns:
    The latitude and longitude of the sector's angular center

### getDeltaLat

    public final Angle getDeltaLat()

  Returns the angular difference between the sector's minimum and maximum latitudes: max - min

  Returns:
    The angular difference between the sector's minimum and maximum latitudes.

### getDeltaLatDegrees

    public final double getDeltaLatDegrees()

### getDeltaLatRadians

    public final double getDeltaLatRadians()

### getDeltaLon

    public final Angle getDeltaLon()

  Returns the angular difference between the sector's minimum and maximum longitudes: max - min.

  Returns:
    The angular difference between the sector's minimum and maximum longitudes

### getDeltaLonDegrees

    public final double getDeltaLonDegrees()

### getDeltaLonRadians

    public final double getDeltaLonRadians()

### getMaxLatitude

    public final Angle getMaxLatitude()

  Returns the sector's maximum latitude.

  Returns:
    The sector's maximum latitude.

### getMaxLongitude

    public final Angle getMaxLongitude()

  Returns the sector's maximum longitude.

  Returns:
    The sector's maximum longitude.

### getMinLatitude

    public final Angle getMinLatitude()

  Returns the sector's minimum latitude.

  Returns:
    The sector's minimum latitude.

### getMinLongitude

    public final Angle getMinLongitude()

  Returns the sector's minimum longitude.

  Returns:
    The sector's minimum longitude.

### getSizeInBytes

    public long getSizeInBytes()

  Retrieve the size of this object in bytes. This implementation returns an exact value of the object's size.

  Specified by:
    `getSizeInBytes` in interface `Cacheable`
  Returns:
    the size of this object in bytes

### hashCode

    public int hashCode()

  Computes a hash code from the sector's four angles.

  Overrides:
    `hashCode` in class `Object`
  Returns:
    a hash code incorporating the sector's four angles.

### intersection

    public final Sector intersection(Angle latitude,
                                     Angle longitude)

### intersection

    public final Sector intersection(Sector that)

### intersects

    public boolean intersects(Sector that)

  Determines whether this sector intersects another sector's range of latitude and longitude. The sector's angles are assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude. The result of the operation is undefined if they are not.

  Parameters:
    `that` - the sector to test for intersection.
  Returns:
    `true` if the sectors intersect, otherwise `false`.

### subdivide

    public final Sector[] subdivide()

### toString

    public String toString()

  Returns a string indicating the sector's angles.

  Overrides:
    `toString` in class `Object`
  Returns:
    A string indicating the sector's angles.

### union

    public final Sector union(Angle latitude,
                              Angle longitude)

### union

    public final Sector union(Sector that)

  Returns a new sector whose angles are the extremes of the this sector and another. The new sector's minimum latitude and longitude will be the minimum of the two sectors. The new sector's maximum latitude and longitude will be the maximum of the two sectors. The sectors are assumed to be normalized to +/- 90 degrees latitude and +/- 180 degrees longitude. The result of the operation is undefined if they are not.

  Parameters:
    `that` - the sector to join with `this`.
  Returns:
    A new sector formed from the extremes of the two sectors, or `this` if the incoming sector is `null`.

Overview | Package | Class | Use | Tree | Index | Help
| NASA World Wind
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD