gov/nasa/worldwind/geom/LatLon.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.*;
  10
  11 /**
  12  * Represents a point on the two-dimensional surface of a globe. Latitude is the degrees North and ranges between [-90,
  13  * 90], while longitude refers to degrees East, and ranges between (-180, 180].
  14  * <p/>
  15  * Instances of <code>LatLon</code> are immutable.
  16  *
  17  * @author Tom Gaskins
  18  * @version $Id: LatLon.java 2152 2007-06-26 20:34:22Z tgaskins $
  19  */
  20 public class LatLon
  21 {
  22     private final Angle latitude;
  23     private final Angle longitude;
  24
  25     /**
  26      * Factor method for obtaining a new <code>LatLon</code> from two angles expressed in radians.
  27      *
  28      * @param latitude  in radians
  29      * @param longitude in radians
  30      * @return a new <code>LatLon</code> from the given angles, which are expressed as radians
  31      */
  32     public static LatLon fromRadians(double latitude, double longitude)
  33     {
  34         return new LatLon(Math.toDegrees(latitude), Math.toDegrees(longitude));
  35     }
  36
  37     /**
  38      * Factory method for obtaining a new <code>LatLon</code> from two angles expressed in degrees.
  39      *
  40      * @param latitude  in degrees
  41      * @param longitude in degrees
  42      * @return a new <code>LatLon</code> from the given angles, which are expressed as degrees
  43      */
  44     public static LatLon fromDegrees(double latitude, double longitude)
  45     {
  46         return new LatLon(latitude, longitude);
  47     }
  48
  49     private LatLon(double latitude, double longitude)
  50     {
  51         this.latitude = Angle.fromDegrees(latitude);
  52         this.longitude = Angle.fromDegrees(longitude);
  53     }
  54
  55     /**
  56      * Contructs a new  <code>LatLon</code> from two angles. Neither angle may be null.
  57      *
  58      * @param latitude
  59      * @param longitude
  60      * @throws IllegalArgumentException if <code>latitude</code> or <code>longitude</code> is null
  61      */
  62     public LatLon(Angle latitude, Angle longitude)
  63     {
  64         if (latitude == null || longitude == null)
  65         {
  66             String message = WorldWind.retrieveErrMsg("nullValue.LatitudeOrLongitudeIsNull");
  67             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  68             throw new IllegalArgumentException(message);
  69         }
  70
  71         this.latitude = latitude;
  72         this.longitude = longitude;
  73     }
  74
  75     /**
  76      * Obtains the latitude of this <code>LatLon</code>.
  77      *
  78      * @return this <code>LatLon</code>'s latitude
  79      */
  80     public final Angle getLatitude()
  81     {
  82         return this.latitude;
  83     }
  84
  85     /**
  86      * Obtains the longitude of this <code>LatLon</code>.
  87      *
  88      * @return this <code>LatLon</code>'s longitude
  89      */
  90     public final Angle getLongitude()
  91     {
  92         return this.longitude;
  93     }
  94
  95     public static LatLon interpolate(double t, LatLon begin, LatLon end)
  96     {
  97         if (begin == null || end == null)
  98         {
  99             String message = WorldWind.retrieveErrMsg("nullValue.LatitudeOrLongitudeIsNull");
 100             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 101             throw new IllegalArgumentException(message);
 102         }
 103
 104         if (t < 0)
 105             return begin;
 106         else if (t > 1)
 107             return end;
 108         Quaternion beginQuat = Quaternion.EulerToQuaternion(begin.getLongitude().getRadians(),
 109             begin.getLatitude().getRadians(), 0);
 110         Quaternion endQuat = Quaternion.EulerToQuaternion(end.getLongitude().getRadians(),
 111             end.getLatitude().getRadians(), 0);
 112         Quaternion q = Quaternion.Slerp(beginQuat, endQuat, t);
 113         Vec4 v = Quaternion.QuaternionToEuler(q);
 114         if (Double.isNaN(v.x) || Double.isNaN(v.y))
 115             return null;
 116         return LatLon.fromRadians(v.y, v.x);
 117     }
 118
 119     /**
 120      * Computes the great circle angular distance between two locations
 121      *
 122      * @param begin LatLon of the first location
 123      * @param end   LatLon of the second location
 124      * @return the angular distance between the two locations
 125      */
 126     public static Angle sphericalDistance(LatLon begin, LatLon end)
 127     {
 128         double radLatA = begin.getLatitude().radians;
 129         double radLatB = end.getLatitude().radians;
 130         double radLonA = begin.getLongitude().radians;
 131         double radLonB = end.getLongitude().radians;
 132         return Angle.fromRadians(
 133             Math.acos(Math.cos(radLatA) * Math.cos(radLatB) * Math.cos(radLonA - radLonB)
 134                 + Math.sin(radLatA) * Math.sin(radLatB)));
 135     }
 136
 137     public LatLon add(LatLon that)
 138     {
 139         if (that == null)
 140         {
 141             String msg = WorldWind.retrieveErrMsg("nullValue.AngleIsNull");
 142             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 143             throw new IllegalArgumentException(msg);
 144         }
 145
 146         Angle lat = Angle.normalizedLatitude(this.latitude.add(that.latitude));
 147         Angle lon = Angle.normalizedLongitude(this.longitude.add(that.longitude));
 148
 149         return new LatLon(lat, lon);
 150     }
 151
 152     public LatLon subtract(LatLon that)
 153     {
 154         if (that == null)
 155         {
 156             String msg = WorldWind.retrieveErrMsg("nullValue.AngleIsNull");
 157             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 158             throw new IllegalArgumentException(msg);
 159         }
 160
 161         Angle lat = Angle.normalizedLatitude(this.latitude.subtract(that.latitude));
 162         Angle lon = Angle.normalizedLongitude(this.longitude.subtract(that.longitude));
 163
 164         return new LatLon(lat, lon);
 165     }
 166
 167     public LatLon add(Position that)
 168     {
 169         if (that == null)
 170         {
 171             String msg = WorldWind.retrieveErrMsg("nullValue.AngleIsNull");
 172             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 173             throw new IllegalArgumentException(msg);
 174         }
 175
 176         Angle lat = Angle.normalizedLatitude(this.latitude.add(that.getLatitude()));
 177         Angle lon = Angle.normalizedLongitude(this.longitude.add(that.getLongitude()));
 178
 179         return new LatLon(lat, lon);
 180     }
 181
 182     public LatLon subtract(Position that)
 183     {
 184         if (that == null)
 185         {
 186             String msg = WorldWind.retrieveErrMsg("nullValue.AngleIsNull");
 187             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 188             throw new IllegalArgumentException(msg);
 189         }
 190
 191         Angle lat = Angle.normalizedLatitude(this.latitude.subtract(that.getLatitude()));
 192         Angle lon = Angle.normalizedLongitude(this.longitude.subtract(that.getLongitude()));
 193
 194         return new LatLon(lat, lon);
 195     }
 196
 197     public static boolean positionsCrossLongitudeBoundary(Iterable<LatLon> positions)
 198     {
 199         if (positions == null)
 200         {
 201             String msg = WorldWind.retrieveErrMsg("nullValue.PositionsListIsNull");
 202             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 203             throw new IllegalArgumentException(msg);
 204         }
 205
 206         LatLon pos = null;
 207         for (LatLon posNext : positions)
 208         {
 209             if (pos != null)
 210             {
 211                 // A segment cross the line if end pos have different longitude signs
 212                 // and are more than 180 degress longitude apart
 213                 if (Math.signum(pos.getLongitude().degrees) != Math.signum(posNext.getLongitude().degrees))
 214                 {
 215                     if (Math.abs(pos.getLongitude().degrees - posNext.getLongitude().degrees) > 180)
 216                         return true;
 217                 }
 218             }
 219             pos = posNext;
 220         }
 221
 222         return false;
 223     }
 224
 225     @Override
 226     public String toString()
 227     {
 228         return "(" + this.latitude.toString() + ", " + this.longitude.toString() + ")";
 229     }
 230
 231     @Override
 232     public boolean equals(Object o)
 233     {
 234         if (this == o)
 235             return true;
 236         if (o == null || getClass() != o.getClass())
 237             return false;
 238
 239         final gov.nasa.worldwind.geom.LatLon latLon = (gov.nasa.worldwind.geom.LatLon) o;
 240
 241         if (!latitude.equals(latLon.latitude))
 242             return false;
 243         //noinspection RedundantIfStatement
 244         if (!longitude.equals(latLon.longitude))
 245             return false;
 246
 247         return true;
 248     }
 249
 250     @Override
 251     public int hashCode()
 252     {
 253         int result;
 254         result = latitude.hashCode();
 255         result = 29 * result + longitude.hashCode();
 256         return result;
 257     }
 258 }