def philam(self):
'''Get the lat- and longitude in C{radians} (L{PhiLam2Tuple}).
'''
if self._philam is None:
self._philam = PhiLam2Tuple(radians(self.latlon.lat),
radians(self.latlon.lon))
return self._xnamed(self._philam)
def philam(self):
'''Get the lat- and longitude ((L{PhiLam2Tuple}C{(phi, lam)}).
'''
if self._philam is None:
r = self.latlon
self._philam = PhiLam2Tuple(Phi_(r.lat), Lam_(r.lon))
return self._xnamed(self._philam)
def point(self, point):
'''Convert C{(lat, lon)} point in degrees to C{(a, b)}
in radians.
@return: An L{PhiLam2Tuple}C{(phi, lam)}.
'''
try:
return point.philam
except AttributeError: # PYCHOK no cover
return PhiLam2Tuple(radians(point.lat), radians(point.lon))
def n_xyz2philam(x, y, z):
'''Convert C{n-vector} components to lat- and longitude in C{radians}.
@arg x: X component (C{scalar}).
@arg y: Y component (C{scalar}).
@arg z: Z component (C{scalar}).
@return: A L{PhiLam2Tuple}C{(phi, lam)}.
@see: Function L{n_xyz2latlon}.
'''
return PhiLam2Tuple(atan2(z, hypot(x, y)), atan2(y, x))
def antipode_(phi, lam):
'''Return the antipode, the point diametrically opposite
to a given point in C{radians}.
@arg phi: Latitude (C{radians}).
@arg lam: Longitude (C{radians}).
@return: A L{PhiLam2Tuple}C{(phi, lam)}.
@see: U{Geosphere<https://CRAN.R-Project.org/web/packages/geosphere/geosphere.pdf>}.
'''
return PhiLam2Tuple(-wrapPI_2(phi), wrapPI(lam + PI))
def philam2(self, ndigits=0):
'''Return this point's lat- and longitude in C{radians}, rounded.
@kwarg ndigits: Number of decimal digits (C{int}).
@return: A L{PhiLam2Tuple}C{(phi, lam)}, both C{float}
and rounded away from zero.
@note: The C{round}ed values are always C{float}, also
if B{C{ndigits}} is omitted.
'''
r = PhiLam2Tuple(round(self.phi, ndigits),
round(self.lam, ndigits))
return self._xnamed(r)
def philam0(self):
'''Get the central origin (L{PhiLam2Tuple}C{(phi, lam)}).
'''
return self._xnamed(PhiLam2Tuple(self.phi0, self.lam0))
def testNvectorBase(self, module, **kwds):
try:
Nvector = module.Nvector
c = Nvector.__name__
except AttributeError:
Nvector = module.NvectorBase
c = 'Vector4Tuple'
self.subtitle(module, Nvector.__name__)
v = Nvector(0.500, 0.500, 0.707, **kwds)
s = module.sumOf((v, v), h=0, name='sumOf')
self.test('sumOf', s.__class__.__name__, c)
p = v.toLatLon(LatLon=None)
c = v.toCartesian(Cartesian=None)
self.test('ecef.x, .y, .z', fstr(p[:3], prec=5), fstr(c[:3], prec=5))
self.test('ecef.lat, .lon', fstr(p[3:5], prec=6), fstr(c[3:5], prec=6))
self.test('ecef.height',
fstr(p.height, prec=6),
fstr(c.height, prec=6),
known=True)
if c.M is not None:
self.test('ecef.M', fstr(p.M, prec=9), fstr(c.M, prec=9))
if coverage:
from pygeodesy.namedTuples import LatLon2Tuple, LatLon3Tuple, \
PhiLam2Tuple, PhiLam3Tuple
self.test('.isEllipsoidal', v.isEllipsoidal, not v.isSpherical)
self.test('.isSpherical', v.isSpherical, not v.isEllipsoidal)
self.test('.latlon', v.latlon, LatLon2Tuple(v.lat, v.lon))
self.test('.philam', v.philam, PhiLam2Tuple(v.phi, v.lam))
self.test('.latlonheight',
v.latlonheight,
LatLon3Tuple(v.lat, v.lon, v.h),
known=v.h in (0, 0.0, NEG0))
self.test('.philamheight',
v.philamheight,
PhiLam3Tuple(v.phi, v.lam, v.h),
known=v.h in (0, 0.0, NEG0))
t = v.parse('0.5, 0.5, 0.707')
self.test('parse', t, v)
self.test('cmp', t.cmp(v), 0)
self.test('eq', t == v, True)
self.test('ge', t >= v, True)
self.test('gt', t > v, False)
self.test('le', t <= v, True)
self.test('lt', t < v, False)
self.test('ne', t != v, False)
m = t * 2
self.test('*', m, '(1.0, 1.0, 1.414)')
self.test('+', t + v, m)
self.test('/', m / 2, t)
self.test('-', m - t, t)
m = v.__matmul__(t)
self.test('@', m, '(0.0, 0.0, 0.0)')
r = t.__rmatmul__(m)
self.test('@', r, m)
r = v.rotate(m, 45)
self.test('rotate', r, '(0.26268, 0.26268, 0.37143)')
r.crosserrors = True
self.test('crosserrors', r.crosserrors, True)
try:
self.test('0', v.dividedBy(0), VectorError.__name__)
except Exception as x:
self.test('0', str(x), 'factor (0): float division by zero')
t = vector3d.intersections2(Nvector(0, 0, 0),
500,
Nvector(1000, 0, 0),
500,
sphere=False)
self.test('intersections2', t[0], t[1]) # abutting
p1, p2 = Nvector(-100, -100, -100), Nvector(100, 100, 100)
t = vector3d.nearestOn(Nvector(0, 0, 0), p1, p2)
self.test('nearestOn', t, Nvector(0, 0, 0))
t = vector3d.nearestOn(Nvector(-200, -200, 0), p1, p2)
self.test('nearestOn', t is p1, True)
t = vector3d.nearestOn(Nvector(200, 200, 0), p1, p2)
self.test('nearestOn', t, p2)
self.test('nearestOn', t is p2, True)
t = vector3d.iscolinearWith(Nvector(200, 200, 0), p1, p2)
self.test('iscolinearWith', t, False)
t = vector3d.iscolinearWith(Nvector(0, 0, 0), p1, p2)
self.test('iscolinearWith', t, True)