def distanceTo(self, other, radius=None, **unused): # for -DistanceTo
'''Approximate the distance from this to an other point.
@arg other: The other point (L{LatLon}).
@kwarg radius: Mean earth radius (C{meter}).
@return: Distance (C{meter}, same units as B{C{radius}}).
@raise TypeError: The B{C{other}} point is not L{LatLon}.
@raise ValueError: Invalid B{C{radius}}.
@example:
>>> p = LatLon(52.205, 0.119)
>>> q = LatLon(48.857, 2.351);
>>> d = p.distanceTo(q) # 404300
'''
self.others(other)
v1 = self._N_vector
v2 = other._N_vector
if radius is None:
r = self.datum.ellipsoid.R1
else:
r = Radius(radius)
return v1.angleTo(v2) * r
def euclidean(lat1, lon1, lat2, lon2, radius=R_M, adjust=True, wrap=False):
'''Approximate the C{Euclidian} distance between two (spherical) points.
@arg lat1: Start latitude (C{degrees}).
@arg lon1: Start longitude (C{degrees}).
@arg lat2: End latitude (C{degrees}).
@arg lon2: End longitude (C{degrees}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg adjust: Adjust the longitudinal delta by the cosine
of the mean latitude (C{bool}).
@kwarg wrap: Wrap and L{unroll180} longitudes (C{bool}).
@return: Distance (C{meter}, same units as B{C{radius}}).
@see: U{Distance between two (spherical) points
<https://www.EdWilliams.org/avform.htm#Dist>}, functions
L{euclidean_}, L{cosineLaw}, L{equirectangular}, L{flatLocal},
L{flatPolar}, L{haversine}, L{vincentys} and methods
L{Ellipsoid.distance2}, C{LatLon.distanceTo*} and
C{LatLon.equirectangularTo}.
'''
r = Radius(radius)
if r:
d, _ = unroll180(lon1, lon2, wrap=wrap)
r *= euclidean_(Phi_(lat2, name='lat2'),
Phi_(lat1, name='lat1'),
radians(d),
adjust=adjust)
return r
def cosineLaw(lat1, lon1, lat2, lon2, radius=R_M, wrap=False):
'''Compute the distance between two points using the
U{spherical Law of Cosines
<https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>}
fromula.
@arg lat1: Start latitude (C{degrees}).
@arg lon1: Start longitude (C{degrees}).
@arg lat2: End latitude (C{degrees}).
@arg lon2: End longitude (C{degrees}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg wrap: Wrap and L{unroll180} longitudes (C{bool}).
@return: Distance (C{meter}, same units as B{C{radius}}).
@raise TypeError: Invalid B{C{datum}}.
@see: Functions L{cosineLaw_}, L{equirectangular}, L{euclidean},
L{flatLocal}, L{flatPolar}, L{haversine}, L{vincentys} and
method L{Ellipsoid.distance2}.
@note: See note at function L{vincentys_}.
'''
r = Radius(radius)
if r:
d, _ = unroll180(lon1, lon2, wrap=wrap)
r *= cosineLaw_(Phi_(lat2, name='lat2'), Phi_(lat1, name='lat1'),
radians(d))
return r
def haversine(lat1, lon1, lat2, lon2, radius=R_M, wrap=False):
'''Compute the distance between two (spherical) points using the
U{Haversine<https://www.Movable-Type.co.UK/scripts/latlong.html>}
formula.
@arg lat1: Start latitude (C{degrees}).
@arg lon1: Start longitude (C{degrees}).
@arg lat2: End latitude (C{degrees}).
@arg lon2: End longitude (C{degrees}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg wrap: Wrap and L{unroll180} longitudes (C{bool}).
@return: Distance (C{meter}, same units as B{C{radius}}).
@see: U{Distance between two (spherical) points
<https://www.EdWilliams.org/avform.htm#Dist>}, functions
L{cosineLaw}, L{equirectangular}, L{euclidean},
L{flatLocal}, L{flatPolar}, L{vincentys} and methods
L{Ellipsoid.distance2}, C{LatLon.distanceTo*} and
C{LatLon.equirectangularTo}.
@note: See note at function L{vincentys_}.
'''
r = Radius(radius)
if r:
d, _ = unroll180(lon1, lon2, wrap=wrap)
r *= haversine_(Phi_(lat2, name='lat2'), Phi_(lat1, name='lat1'),
radians(d))
return r
def flatPolar(lat1, lon1, lat2, lon2, radius=R_M, wrap=False):
'''Compute the distance between two (spherical) points using
the U{polar coordinate flat-Earth
<https://WikiPedia.org/wiki/Geographical_distance#Polar_coordinate_flat-Earth_formula>}
formula.
@arg lat1: Start latitude (C{degrees}).
@arg lon1: Start longitude (C{degrees}).
@arg lat2: End latitude (C{degrees}).
@arg lon2: End longitude (C{degrees}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg wrap: Wrap and L{unroll180} longitudes (C{bool}).
@return: Distance (C{meter}, same units as B{C{radius}}).
@see: Functions L{flatPolar_}, L{cosineLaw}, L{flatLocal},
L{equirectangular}, L{euclidean}, L{haversine} and
L{vincentys}.
'''
r = Radius(radius)
if r:
d, _ = unroll180(lon1, lon2, wrap=wrap)
r *= flatPolar_(Phi_(lat2, name='lat2'), Phi_(lat1, name='lat1'),
radians(d))
return r
def rhumbDistanceTo(self, other, radius=R_M):
'''Return the distance from this to an other point along a rhumb
(loxodrome) line.
@arg other: The other point (spherical C{LatLon}).
@kwarg radius: Mean earth radius (C{meter}).
@return: Distance (C{meter}, the same units as I{radius}).
@raise TypeError: The B{C{other}} point is not spherical.
@raise ValueError: Invalid B{C{radius}}.
@example:
>>> p = LatLon(51.127, 1.338)
>>> q = LatLon(50.964, 1.853)
>>> d = p.rhumbDistanceTo(q) # 403100
'''
# see <https://www.EdWilliams.org/avform.htm#Rhumb>
da, db, dp = self._rhumb3(other)
# on Mercator projection, longitude distances shrink
# by latitude; the 'stretch factor' q becomes ill-
# conditioned along E-W line (0/0); use an empirical
# tolerance to avoid it
q = (da / dp) if abs(dp) > EPS else cos(self.phi)
return hypot(da, q * db) * Radius(radius)
def perimeterOf(points, closed=False, radius=R_M):
'''Compute the perimeter of a (spherical) polygon (with great circle
arcs joining consecutive points).
@arg points: The polygon points (L{LatLon}[]).
@kwarg closed: Optionally, close the polygon (C{bool}).
@kwarg radius: Mean earth radius (C{meter}).
@return: Polygon perimeter (C{meter}, same units as B{C{radius}}).
@raise PointsError: Insufficient number of B{C{points}}.
@raise TypeError: Some B{C{points}} are not L{LatLon}.
@see: L{pygeodesy.perimeterOf}, L{sphericalTrigonometry.perimeterOf}
and L{ellipsoidalKarney.perimeterOf}.
'''
n, points = _Nvll.points2(points, closed=closed)
def _rads(n, points, closed): # angular edge lengths in radians
i, m = _imdex2(closed, n)
v1 = points[i]._N_vector
for i in range(m, n):
v2 = points[i]._N_vector
yield v1.angleTo(v2)
v1 = v2
r = fsum(_rads(n, points, closed))
return r * Radius(radius)
def heightOf(angle, distance, radius=R_M):
'''Determine the height above the (spherical) earth after
traveling along a straight line at a given tilt.
@arg angle: Tilt angle above horizontal (C{degrees}).
@arg distance: Distance along the line (C{meter} or same units as
B{C{radius}}).
@kwarg radius: Optional mean earth radius (C{meter}).
@return: Height (C{meter}, same units as B{C{distance}} and B{C{radius}}).
@raise ValueError: Invalid B{C{angle}}, B{C{distance}} or B{C{radius}}.
@see: U{MultiDop geog_lib.GeogBeamHt<https://GitHub.com/NASA/MultiDop>}
(U{Shapiro et al. 2009, JTECH
<https://Journals.AMetSoc.org/doi/abs/10.1175/2009JTECHA1256.1>}
and U{Potvin et al. 2012, JTECH
<https://Journals.AMetSoc.org/doi/abs/10.1175/JTECH-D-11-00019.1>}).
'''
r = h = Radius(radius)
d = abs(Distance(distance))
if d > h:
d, h = h, d
if d > EPS:
d = d / h # PyChecker chokes on ... /= ...
s = sin(Phi_(angle, name='angle', clip=180))
s = fsum_(1, 2 * s * d, d**2)
if s > 0:
return h * sqrt(s) - r
raise InvalidError(angle=angle, distance=distance, radius=radius)
def flatLocalTo(self, other, radius=None, wrap=False):
'''Compute the distance between this and an other point using the
U{ellipsoidal Earth to plane projection
<https://WikiPedia.org/wiki/Geographical_distance#Ellipsoidal_Earth_projected_to_a_plane>}
aka U{Hubeny<https://www.OVG.AT/de/vgi/files/pdf/3781/>} formula.
@arg other: The other point (C{LatLon}).
@kwarg radius: Mean earth radius (C{meter}) or C{None} for the
major radius of this point's datum/ellipsoid.
@kwarg wrap: Wrap and L{unroll180} longitudes (C{bool}).
@return: Distance (C{meter}, same units as B{C{radius}}).
@raise TypeError: The B{C{other}} point is not C{LatLon}.
@raise ValueError: Invalid B{C{radius}}.
@see: Function L{flatLocal}/L{hubeny}, methods C{cosineAndoyerLambertTo},
C{cosineForsytheAndoyerLambertTo}, C{cosineLawTo},
C{distanceTo*}, C{equirectangularTo}, C{euclideanTo},
C{flatPolarTo}, C{haversineTo}, C{thomasTo} and
C{vincentysTo} and U{local, flat Earth approximation
<https://www.edwilliams.org/avform.htm#flat>}.
'''
E = self.datum.ellipsoid
r = self._distanceTo_(flatLocal_, other, wrap=wrap) * E.a2_
a = E.a if radius in (None, 1, _1_0) else Radius(radius)
return r * a
def vincentys(lat1, lon1, lat2, lon2, radius=R_M, wrap=False):
'''Compute the distance between two (spherical) points using
U{Vincenty's<https://WikiPedia.org/wiki/Great-circle_distance>}
spherical formula.
@arg lat1: Start latitude (C{degrees}).
@arg lon1: Start longitude (C{degrees}).
@arg lat2: End latitude (C{degrees}).
@arg lon2: End longitude (C{degrees}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg wrap: Wrap and L{unroll180} longitudes (C{bool}).
@return: Distance (C{meter}, same units as B{C{radius}}).
@see: Functions L{vincentys_}, L{cosineLaw}, L{equirectangular},
L{euclidean}, L{flatLocal}, L{flatPolar}, L{haversine} and
methods L{Ellipsoid.distance2}, C{LatLon.distanceTo*} and
C{LatLon.equirectangularTo}.
@note: See note at function L{vincentys_}.
'''
r = Radius(radius)
if r:
d, _ = unroll180(lon1, lon2, wrap=wrap)
r *= vincentys_(Phi_(lat2, name='lat2'), Phi_(lat1, name='lat1'),
radians(d))
return r
def distanceTo(self, other, radius=R_M, wrap=False):
'''Compute the distance from this to an other point.
@arg other: The other point (L{LatLon}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg wrap: Wrap and unroll longitudes (C{bool}).
@return: Distance between this and the B{C{other}} point
(C{meter}, same units as B{C{radius}}).
@raise TypeError: The B{C{other}} point is not L{LatLon}.
@raise ValueError: Invalid B{C{radius}}.
@example:
>>> p1 = LatLon(52.205, 0.119)
>>> p2 = LatLon(48.857, 2.351);
>>> d = p1.distanceTo(p2) # 404300
'''
self.others(other)
a1, b1 = self.philam
a2, b2 = other.philam
db, _ = unrollPI(b1, b2, wrap=wrap)
r = haversine_(a2, a1, db)
return r * Radius(radius)
def perimeterOf(points, closed=False, radius=R_M, wrap=True):
'''Compute the perimeter of a (spherical) polygon (with great circle
arcs joining the points).
@arg points: The polygon points (L{LatLon}[]).
@kwarg closed: Optionally, close the polygon (C{bool}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg wrap: Wrap and unroll longitudes (C{bool}).
@return: Polygon perimeter (C{meter}, same units as B{C{radius}}).
@raise PointsError: Insufficient number of B{C{points}}.
@raise TypeError: Some B{C{points}} are not L{LatLon}.
@raise ValueError: Invalid B{C{radius}}.
@note: This perimeter is based on the L{haversine} formula.
@see: L{pygeodesy.perimeterOf}, L{sphericalNvector.perimeterOf}
and L{ellipsoidalKarney.perimeterOf}.
'''
n, points = _Trll.points2(points, closed=closed)
def _rads(n, points, closed): # angular edge lengths in radians
i, m = _imdex2(closed, n)
a1, b1 = points[i].philam
for i in range(m, n):
a2, b2 = points[i].philam
db, b2 = unrollPI(b1, b2, wrap=wrap)
yield haversine_(a2, a1, db)
a1, b1 = a2, b2
r = fsum(_rads(n, points, closed))
return r * Radius(radius)
def areaOf(points, radius=R_M, wrap=True):
'''Calculate the area of a (spherical) polygon (with great circle
arcs joining the points).
@arg points: The polygon points (L{LatLon}[]).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg wrap: Wrap and unroll longitudes (C{bool}).
@return: Polygon area (C{meter}, same units as B{C{radius}}, squared).
@raise PointsError: Insufficient number of B{C{points}}.
@raise TypeError: Some B{C{points}} are not L{LatLon}.
@raise ValueError: Invalid B{C{radius}}.
@note: The area is based on Karney's U{'Area of a spherical polygon'
<https://OSGeo-org.1560.x6.nabble.com/
Area-of-a-spherical-polygon-td3841625.html>}.
@see: L{pygeodesy.areaOf}, L{sphericalNvector.areaOf} and
L{ellipsoidalKarney.areaOf}.
@example:
>>> b = LatLon(45, 1), LatLon(45, 2), LatLon(46, 2), LatLon(46, 1)
>>> areaOf(b) # 8666058750.718977
>>> c = LatLon(0, 0), LatLon(1, 0), LatLon(0, 1)
>>> areaOf(c) # 6.18e9
'''
n, points = _Trll.points2(points, closed=True)
# Area method due to Karney: for each edge of the polygon,
#
# tan(Δλ/2) · (tan(φ1/2) + tan(φ2/2))
# tan(E/2) = ------------------------------------
# 1 + tan(φ1/2) · tan(φ2/2)
#
# where E is the spherical excess of the trapezium obtained by
# extending the edge to the equator-circle vector for each edge
def _exs(n, points): # iterate over spherical edge excess
a1, b1 = points[n - 1].philam
ta1 = tan_2(a1)
for i in range(n):
a2, b2 = points[i].philam
db, b2 = unrollPI(b1, b2, wrap=wrap)
ta2, tdb = map1(tan_2, a2, db)
yield atan2(tdb * (ta1 + ta2), 1 + ta1 * ta2)
ta1, b1 = ta2, b2
s = fsum(_exs(n, points)) * 2
if isPoleEnclosedBy(points):
s = abs(s) - PI2
return abs(s * Radius(radius)**2)
def _intersects2(center1, r1, center2, r2, sphere=True, too_d=None, # in .ellipsoidalBase._intersections2
Vector=None, **Vector_kwds):
# (INTERNAL) Intersect two spheres or circles, see L{intersections2}
# above, separated to allow callers to embellish any exceptions
def _V3(x, y, z):
v = Vector3d(x, y, z)
n = intersections2.__name__
return _V_n(v, n, Vector, Vector_kwds)
def _xV3(c1, u, x, y):
xy1 = x, y, _1_0 # transform to original space
return _V3(fdot(xy1, u.x, -u.y, c1.x),
fdot(xy1, u.y, u.x, c1.y), _0_0)
c1 = _otherV3d(sphere=sphere, center1=center1)
c2 = _otherV3d(sphere=sphere, center2=center2)
if r1 < r2: # r1, r2 == R, r
c1, c2 = c2, c1
r1, r2 = r2, r1
m = c2.minus(c1)
d = m.length
if d < max(r2 - r1, EPS):
raise ValueError(_near_concentric_)
o = fsum_(-d, r1, r2) # overlap == -(d - (r1 + r2))
# compute intersections with c1 at (0, 0) and c2 at (d, 0), like
# <https://MathWorld.Wolfram.com/Circle-CircleIntersection.html>
if o > EPS: # overlapping, r1, r2 == R, r
x = _radical2(d, r1, r2).xline
y = _1_0 - (x / r1)**2
if y > EPS:
y = r1 * sqrt(y) # y == a / 2
elif y < 0:
raise ValueError(_invalid_)
else: # abutting
y = _0_0
elif o < 0:
t = d if too_d is None else too_d
raise ValueError(_too_(Fmt.distant(t)))
else: # abutting
x, y = r1, _0_0
u = m.unit()
if sphere: # sphere center and radius
c = c1 if x < EPS else (
c2 if x > EPS1 else c1.plus(u.times(x)))
t = _V3(c.x, c.y, c.z), Radius(y)
elif y > 0: # intersecting circles
t = _xV3(c1, u, x, y), _xV3(c1, u, x, -y)
else: # abutting circles
t = _xV3(c1, u, x, 0)
t = t, t
return t
def toWm(latlon, lon=None, radius=R_MA, Wm=Wm, name='', **Wm_kwds):
'''Convert a lat-/longitude point to a WM coordinate.
@arg latlon: Latitude (C{degrees}) or an (ellipsoidal or
spherical) geodetic C{LatLon} point.
@kwarg lon: Optional longitude (C{degrees} or C{None}).
@kwarg radius: Optional earth radius (C{meter}).
@kwarg Wm: Optional class to return the WM coordinate
(L{Wm}) or C{None}.
@kwarg name: Optional name (C{str}).
@kwarg Wm_kwds: Optional, additional B{C{Wm}} keyword
arguments, ignored if B{C{Wm=None}}.
@return: The WM coordinate (B{C{Wm}}) or an
L{EasNorRadius3Tuple}C{(easting, northing, radius)}
if B{C{Wm}} is C{None}.
@raise ValueError: If B{C{lon}} value is missing, if B{C{latlon}}
is not scalar, if B{C{latlon}} is beyond the
valid WM range and L{rangerrors} is set
to C{True} or if B{C{radius}} is invalid.
@example:
>>> p = LatLon(48.8582, 2.2945) # 448251.8 5411932.7
>>> w = toWm(p) # 448252 5411933
>>> p = LatLon(13.4125, 103.8667) # 377302.4 1483034.8
>>> w = toWm(p) # 377302 1483035
'''
e, r = None, Radius(radius)
try:
lat, lon = latlon.lat, latlon.lon
if isinstance(latlon, _LLEB):
r = latlon.datum.ellipsoid.a
e = latlon.datum.ellipsoid.e
if not name: # use latlon.name
name = nameof(latlon)
lat = clipDegrees(lat, _LatLimit)
except AttributeError:
lat, lon = parseDMS2(latlon, lon, clipLat=_LatLimit)
s = sin(radians(lat))
y = atanh(s) # == log(tan((90 + lat) / 2)) == log(tanPI_2_2(radians(lat)))
if e:
y -= e * atanh(e * s)
e, n = r * radians(lon), r * y
if Wm is None:
r = EasNorRadius3Tuple(e, n, r)
else:
kwds = _xkwds(Wm_kwds, radius=r)
r = Wm(e, n, **kwds)
return _xnamed(r, name)
def m2degrees(meter, radius=R_M, lat=0):
'''Convert distance to angle along equator or along a
parallel at an other latitude.
@arg meter: Distance (C{meter}, same units as B{C{radius}}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg lat: Parallel latitude (C{degrees90}, C{str}).
@return: Angle (C{degrees}).
@raise RangeError: Latitude B{C{lat}} outside valid range
and L{rangerrors} set to C{True}.
@raise ValueError: Invalid B{C{meter}}, B{C{radius}} or
B{C{lat}}.
@see: Function L{degrees2m}.
'''
r = Radius(radius)
if lat:
r *= cos(Phi_(lat))
return degrees(Meter(meter) / r)
def distanceTo(self, other, radius=R_M, wrap=False):
'''Compute the distance from this to an other point.
@arg other: The other point (L{LatLon}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg wrap: Wrap/unroll the angular distance (C{bool}).
@return: Distance between this and the B{C{other}} point
(C{meter}, same units as B{C{radius}}).
@raise TypeError: Invalid B{C{other}} point.
@example:
>>> p = LatLon(52.205, 0.119)
>>> q = LatLon(48.857, 2.351);
>>> d = p.distanceTo(q) # 404.3 km
'''
self.others(other)
a = self.toNvector().angleTo(other.toNvector(), wrap=wrap)
return abs(a) * (radius if radius is R_M else Radius(radius))
def degrees2m(deg, radius=R_M, lat=0):
'''Convert angle to distance along the equator or along a
parallel at an other latitude.
@arg deg: Angle (C{degrees}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg lat: Parallel latitude (C{degrees90}, C{str}).
@return: Distance (C{meter}, same units as B{C{radius}}).
@raise RangeError: Latitude B{C{lat}} outside valid range
and L{rangerrors} set to C{True}.
@raise ValueError: Invalid B{C{deg}}, B{C{radius}} or
B{C{lat}}.
@see: Function L{m2degrees}.
'''
m = Lam_(deg, name=_deg_, clip=0) * Radius(radius)
if lat:
m *= cos(Phi_(lat))
return float(m)
def distance3To(self, other, radius=R_M, wrap=False):
'''Compute the great-circle distance between this and an other
geohash using the U{Haversine
<https://www.Movable-Type.co.UK/scripts/latlong.html>} formula.
@arg other: The other geohash (L{Geohash}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg wrap: Wrap and unroll longitudes (C{bool}).
@return: Great-circle distance (C{meter}, same units as I{radius}).
@raise TypeError: The I{other} is not a L{Geohash}, C{LatLon}
or C{str}.
@raise ValueError: Invalid B{C{radius}}.
'''
other = _2Geohash(other)
a1, b1 = self.ab
a2, b2 = other.ab
db, _ = unrollPI(b1, b2, wrap=wrap)
return haversine_(a2, a1, db) * Radius(radius)
def horizon(height, radius=R_M, refraction=False):
'''Determine the distance to the horizon from a given altitude
above the (spherical) earth.
@arg height: Altitude (C{meter} or same units as B{C{radius}}).
@kwarg radius: Optional mean earth radius (C{meter}).
@kwarg refraction: Consider atmospheric refraction (C{bool}).
@return: Distance (C{meter}, same units as B{C{height}} and B{C{radius}}).
@raise ValueError: Invalid B{C{height}} or B{C{radius}}.
@see: U{Distance to horizon<https://www.EdWilliams.org/avform.htm#Horizon>}.
'''
h, r = Height(height), Radius(radius)
if min(h, r) < 0:
raise InvalidError(height=height, radius=radius)
if refraction:
d2 = 2.415750694528 * h * r # 2.0 / 0.8279
else:
d2 = h * fsum_(r, r, h)
return sqrt(d2)
def nearestOn3(self, points, closed=False, radius=R_M, height=None):
'''Locate the point on a polygon (with great circle arcs
joining consecutive points) closest to this point.
If this point is within the extent of any great circle
arc, the closest point is on that arc. Otherwise,
the closest is the nearest of the arc's end points.
@arg points: The polygon points (L{LatLon}[]).
@kwarg closed: Optionally, close the polygon (C{bool}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg height: Optional height, overriding the mean height
for a point within the arc (C{meter}).
@return: A L{NearestOn3Tuple}C{(closest, distance, angle)} of
the C{closest} point (L{LatLon}), the C{distance}
between this and the C{closest} point in C{meter},
same units as B{C{radius}} and the C{angle} from
this to the C{closest} point in compass C{degrees360}.
@raise TypeError: Some B{C{points}} are not C{LatLon}.
@raise ValueError: No B{C{points}}.
'''
n, points = self.points2(points, closed=closed)
i, m = _imdex2(closed, n)
c = p2 = points[i]
r = self.distanceTo(c, radius=1) # force radians
for i in range(m, n):
p1, p2 = p2, points[i]
p = self.nearestOn(p1, p2, height=height)
t = self.distanceTo(p, radius=1) # force radians
if t < r:
c, r = p, t
return NearestOn3Tuple(c, r * Radius(radius), degrees360(r))
def flatLocalTo(self, other, radius=None, wrap=False):
'''Compute the distance between this and an other point using the
U{ellipsoidal Earth to plane projection
<https://WikiPedia.org/wiki/Geographical_distance#Ellipsoidal_Earth_projected_to_a_plane>}
formula.
@arg other: The other point (C{LatLon}).
@kwarg radius: Mean earth radius (C{meter}) or C{None}
for the mean radius of this point's datum
ellipsoid.
@kwarg wrap: Wrap and L{unroll180} longitudes (C{bool}).
@return: Distance (C{meter}, same units as this B{C{datum}}'s
ellipsoid axes).
@raise TypeError: The B{C{other}} point is not C{LatLon}.
@raise ValueError: Invalid B{C{radius}}.
@see: Function L{flatLocal}, methods C{cosineLawTo},
C{distanceTo*}, C{equirectangularTo}, C{euclideanTo},
C{flatPolarTo}, C{haversineTo} and C{vincentysTo}
and U{local, flat Earth approximation
<https://www.edwilliams.org/avform.htm#flat>}.
'''
if radius is None:
self.others(other)
r = 1
else:
r = Radius(radius) / self.datum.ellipsoid.a
return r * flatLocal(self.lat,
self.lon,
other.lat,
other.lon,
datum=self.datum,
wrap=wrap)
def distanceTo(self, other, radius=None, wrap=False):
'''Approximate the distance from this to an other point.
@arg other: The other point (L{LatLon}).
@kwarg radius: Mean earth radius (C{meter}).
@kwarg wrap: Wrap/unroll the angular distance (C{bool}).
@return: Distance (C{meter}, same units as B{C{radius}}).
@raise TypeError: The B{C{other}} point is not L{LatLon}.
@raise ValueError: Invalid B{C{radius}}.
@example:
>>> p = LatLon(52.205, 0.119)
>>> q = LatLon(48.857, 2.351);
>>> d = p.distanceTo(q) # 404300
'''
self.others(other)
a = self._N_vector.angleTo(other._N_vector, wrap=wrap)
r = Radius(radius) if radius else self.datum.ellipsoid.R1
return abs(a) * r
def _r2m(NM, name):
return Radius(NM / m2NM(1), name=name, Error=WGRSError)
def areaOf(points, radius=R_M):
'''Calculate the area of a (spherical) polygon (with great circle
arcs joining consecutive points).
@arg points: The polygon points (L{LatLon}[]).
@kwarg radius: Mean earth radius (C{meter}).
@return: Polygon area (C{meter}, same units as B{C{radius}}, squared).
@raise PointsError: Insufficient number of B{C{points}}.
@raise TypeError: Some B{C{points}} are not L{LatLon}.
@see: L{pygeodesy.areaOf}, L{sphericalTrigonometry.areaOf} and
L{ellipsoidalKarney.areaOf}.
@example:
>>> b = LatLon(45, 1), LatLon(45, 2), LatLon(46, 2), LatLon(46, 1)
>>> areaOf(b) # 8666058750.718977
'''
n, points = _Nvll.points2(points, closed=True)
# use vector to 1st point as plane normal for sign of α
n0 = points[0].toNvector()
if iterNumpy2(points):
def _interangles(n, points, n0): # iterate
v2 = points[n-2]._N_vector
v1 = points[n-1]._N_vector
gc = v2.cross(v1)
for i in range(n):
v2 = points[i]._N_vector
gc1 = v1.cross(v2)
v1 = v2
yield gc.angleTo(gc1, vSign=n0)
gc = gc1
# sum interior angles
s = fsum(_interangles(n, points, n0))
else:
# get great-circle vector for each edge
gc, v1 = [], points[n-1]._N_vector
for i in range(n):
v2 = points[i]._N_vector
gc.append(v1.cross(v2)) # PYCHOK false, does have .cross
v1 = v2
gc.append(gc[0]) # XXX needed?
# sum interior angles: depending on whether polygon is cw or ccw,
# angle between edges is π−α or π+α, where α is angle between
# great-circle vectors; so sum α, then take n·π − |Σα| (cannot
# use Σ(π−|α|) as concave polygons would fail)
s = fsum(gc[i].angleTo(gc[i+1], vSign=n0) for i in range(n))
# using Girard’s theorem: A = [Σθᵢ − (n−2)·π]·R²
# (PI2 - abs(s) == (n*PI - abs(s)) - (n-2)*PI)
return abs(PI2 - abs(s)) * Radius(radius)**2
def __new__(cls, e, n, r):
return _NamedTuple.__new__(cls, Easting(e, Error=WebMercatorError),
Northing(n, Error=WebMercatorError),
Radius(r, Error=WebMercatorError))
