def decode(geohash):
'''Decode a geohash to lat-/longitude of the (approximate
centre of) geohash cell, to reasonable precision.
@param geohash: To be decoded (L{Geohash}).
@return: 2-Tuple C{"(latStr, lonStr)"} in (C{str}).
@raise TypeError: The B{C{geohash}} is not a L{Geohash},
C{LatLon} or C{str}.
@raise GeohashError: Invalid or null B{C{geohash}}.
@example:
>>> geohash.decode('u120fxw') # '52.205', '0.1188'
>>> geohash.decode('sunny') # '23.708', '42.473' Saudi Arabia
>>> geohash.decode('fur') # '69.6', '-45.7' Greenland
>>> geohash.decode('reef') # '-24.87', '162.95' Coral Sea
>>> geohash.decode('geek') # '65.48', '-17.75' Iceland
'''
s, w, n, e = bounds(geohash)
# round to near centre without excessive precision
# ⌊2-log10(Δ°)⌋ decimal places, strip trailing zeros
lat = fStr(favg(n, s), prec=int(2 - log10(n - s)))
lon = fStr(favg(e, w), prec=int(2 - log10(e - w)))
return lat, lon # strings
def _toStr4_6(self, hemipole, B, cs, prec, sep):
'''(INTERNAL) Return a string representation of this UTM/UPS coordinate.
'''
z = '%02d%s' % (self.zone, (self.band if B else '')) # PYCHOK band
t = (z, hemipole, fStr(self.easting,
prec=prec), fStr(self.northing, prec=prec))
if cs:
t += ('n/a' if self.convergence is None else degDMS(
self.convergence, prec=8, pos='+'),
'n/a' if self.scale is None else fStr(self.scale, prec=8))
return sep.join(t)
def equirectangular_(lat1,
lon1,
lat2,
lon2,
adjust=True,
limit=45,
wrap=False):
'''Compute the distance between two points using
the U{Equirectangular Approximation / Projection
<https://www.Movable-Type.co.UK/scripts/latlong.html>}.
This approximation is valid for short distance of several
hundred Km or Miles, see the B{C{limit}} keyword argument and
the L{LimitError}.
@param lat1: Start latitude (C{degrees}).
@param lon1: Start longitude (C{degrees}).
@param lat2: End latitude (C{degrees}).
@param lon2: End longitude (C{degrees}).
@keyword adjust: Adjust the wrapped, unrolled longitudinal
delta by the cosine of the mean latitude (C{bool}).
@keyword limit: Optional limit for lat- and longitudinal deltas
(C{degrees}) or C{None} or C{0} for unlimited.
@keyword wrap: Wrap and L{unroll180} longitudes (C{bool}).
@return: A L{Distance4Tuple}C{(distance2, delta_lat, delta_lon,
unroll_lon2)}.
@raise LimitError: If the lat- and/or longitudinal delta exceeds
the B{C{-limit..+limit}} range and L{limiterrors}
set to C{True}.
@see: U{Local, flat earth approximation
<https://www.EdWilliams.org/avform.htm#flat>}, functions
L{equirectangular}, L{euclidean}, L{haversine} and
L{vincentys} and methods L{Ellipsoid.distance2},
C{LatLon.distanceTo*} and C{LatLon.equirectangularTo}.
'''
d_lat = lat2 - lat1
d_lon, ulon2 = unroll180(lon1, lon2, wrap=wrap)
if limit and _limiterrors \
and max(abs(d_lat), abs(d_lon)) > limit > 0:
t = fStr((lat1, lon1, lat2, lon2), prec=4)
raise LimitError('%s(%s, limit=%s) delta exceeds limit' %
('equirectangular_', t, fStr(limit, prec=2)))
if adjust: # scale delta lon
d_lon *= _scaled(lat1, lat2)
d2 = hypot2(d_lat, d_lon) # degrees squared!
return Distance4Tuple(d2, d_lat, d_lon, ulon2 - lon2)
def toStr(self, prec=6, sep=' ', m='m'): # PYCHOK expected
'''Return a string representation of this L{Css} position.
@keyword prec: Optional number of decimal, unstripped (C{int}).
@keyword sep: Optional separator to join (C{str}).
@keyword m: Optional height units, default C{meter} (C{str}).
@return: This position as C{"easting nothing"} C{str} in
C{meter} plus C{" height"} and C{'m'} if heigth
is non-zero (C{str}).
'''
t = [fStr(self.easting, prec=prec), fStr(self.northing, prec=prec)]
if self.height:
t += ['%+.2f%s' % (self.height, m)]
return sep.join(t)
def toStr(self, prec=3, sep=' ', radius=False): # PYCHOK expected
'''Return a string representation of this WM coordinate.
@keyword prec: Optional number of decimals, unstripped (C{int}).
@keyword sep: Optional separator to join (C{str}).
@keyword radius: Optionally, include radius (C{bool} or C{scalar}).
@return: This WM as "meter meter" (C{str}) plus " radius"
if B{C{radius}} is C{True} or C{scalar}.
@raise WebMercatorError: Invalid B{C{radius}}.
@example:
>>> w = Wm(448251, 5411932.0001)
>>> w.toStr(4) # 448251.0 5411932.0001
>>> w.toStr(sep=', ') # 448251, 5411932
'''
fs = self._x, self._y
if radius in (False, None):
pass
elif radius is True:
fs += (self._radius,)
elif isscalar(radius):
fs += (radius,)
else:
raise WebMercatorError('% invalid: %r' % ('radius', radius))
return fStr(fs, prec=prec, sep=sep)
def toStr(self, prec=6, sep=' '): # PYCHOK expected
'''Return a string representation of this projection.
@keyword prec: Optional number of decimal, unstripped (C{int}).
@keyword sep: Optional separator to join (C{str}).
@return: This projection as C{"lat0 lon0"} (C{str}).
'''
return fStr(self.latlon0, prec=prec, sep=sep)
def clipDMS(deg, limit):
'''Clip a lat- or longitude to the given range.
@param deg: Unclipped lat- or longitude (C{degrees}).
@param limit: Valid B{C{-limit..+limit}} range (C{degrees}).
@return: Clipped value (C{degrees}).
@raise RangeError: If B{C{abs(deg)}} beyond B{C{limit}} and
L{rangerrors} set to C{True}.
'''
if limit > 0:
c = min(limit, max(-limit, deg))
if _rangerrors and deg != c:
raise RangeError('%s beyond %s degrees' % (fStr(
deg, prec=6), fStr(copysign(limit, deg), prec=3, ints=True)))
deg = c
return deg
def toStr(self, prec=5, fmt='(%s)', sep=', '): # PYCHOK expected
'''Return a string representation of this vector.
@keyword prec: Optional number of decimal places (C{int}).
@keyword fmt: Optional, enclosing format to use (C{str}).
@keyword sep: Optional separator between components (C{str}).
@return: Vector as "(x, y, z)" (C{str}).
'''
return fmt % (fStr(self.to3xyz(), prec=prec, sep=sep), )
def _fStr(self, prec, *attrs, **others):
'''(INTERNAL) Format.
'''
t = fStr([getattr(self, a) for a in attrs],
prec=prec,
sep=' ',
ints=True)
t = ['%s=%s' % (a, v) for a, v in zip(attrs, t.split())]
if others:
t += ['%s=%s' % (a, v) for a, v in sorted(others.items())]
return ', '.join(['name=%r' % (self.name, )] + t)
def toStr(self, prec=3, fmt='[%s]', sep=', '): # PYCHOK expected
'''Return a string representation of this NED vector.
@keyword prec: Optional number of decimals, unstripped (C{int}).
@keyword fmt: Optional enclosing backets format (C{str}).
@keyword sep: Optional separator between NEDs (C{str}).
@return: This Ned as "[N:f, E:f, D:f]" (C{str}).
'''
t3 = fStr(self.to3ned(), prec=prec, sep=' ').split()
return fmt % (sep.join('%s:%s' % t for t in zip('NED', t3)), )
def toStr(self, prec=0, sep=' ', m='m'): # PYCHOK expected
'''Return a string representation of this L{Lcc} position.
@keyword prec: Optional number of decimal, unstripped (C{int}).
@keyword sep: Optional separator to join (C{str}).
@keyword m: Optional height units, default C{meter} (C{str}).
@return: This Lcc as "easting nothing" C{str} in C{meter} plus
" height" and 'm' if heigth is non-zero (C{str}).
@example:
>>> lb = Lcc(448251, 5411932.0001)
>>> lb.toStr(4) # 448251.0 5411932.0001
>>> lb.toStr(sep=', ') # 448251, 5411932
'''
t = [fStr(self._easting, prec=prec), fStr(self._northing, prec=prec)]
if self._height:
t += ['%+.2f%s' % (self._height, m)]
return sep.join(t)
def toStr2(self, prec=None, fmt='[%s]', sep=', '): # PYCHOK expected
'''Return a string representation of this NED vector as
length, bearing and elevation.
@keyword prec: Optional number of decimals, unstripped (C{int}).
@keyword fmt: Optional enclosing backets format (C{str}).
@keyword sep: Optional separator between NEDs (C{str}).
@return: This Ned as "[L:f, B:degrees360, E:degrees90]" (C{str}).
'''
from pygeodesy.dms import F_D, toDMS
t3 = (fStr(self.length, prec=3 if prec is None else prec),
toDMS(self.bearing, form=F_D, prec=prec,
ddd=0), toDMS(self.elevation, form=F_D, prec=prec, ddd=0))
return fmt % (sep.join('%s:%s' % t for t in zip('LBE', t3)), )
def _error(fun, lat, lon, e):
'''(INTERNAL) Format an error
'''
return '%s(%s): %s' % (fun.__name__, fStr((lat, lon)), e)
def _fStr(a):
return '%s=%s' % (a, fStr(getattr(this, a), prec=prec))
