Coverage for pygeodesy/latlonBase.py: 94%
476 statements
« prev ^ index » next coverage.py v7.2.2, created at 2023-12-29 12:35 -0500
« prev ^ index » next coverage.py v7.2.2, created at 2023-12-29 12:35 -0500
2# -*- coding: utf-8 -*-
4u'''(INTERNAL) Base class L{LatLonBase} for all elliposiodal, spherical and N-vectorial C{LatLon} classes.
6@see: I{(C) Chris Veness}' U{latlong<https://www.Movable-Type.co.UK/scripts/latlong.html>},
7 U{-ellipsoidal<https://www.Movable-Type.co.UK/scripts/geodesy/docs/latlon-ellipsoidal.js.html>} and
8 U{-vectors<https://www.Movable-Type.co.UK/scripts/latlong-vectors.html>} and I{Charles Karney}'s
9 U{Rhumb<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1Rhumb.html>} and
10 U{RhumbLine<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1RhumbLine.html>} classes.
11'''
13from pygeodesy.basics import isstr, map1, _xinstanceof
14from pygeodesy.constants import EPS, EPS0, EPS1, EPS4, INT0, R_M, \
15 _EPSqrt as _TOL, _0_0, _0_5, _1_0, \
16 _360_0, _umod_360
17from pygeodesy.datums import _spherical_datum
18from pygeodesy.dms import F_D, F_DMS, latDMS, lonDMS, parse3llh
19# from pygeodesy.ecef import EcefKarney # _MODS
20from pygeodesy.errors import _AttributeError, _incompatible, \
21 _IsnotError, IntersectionError, \
22 _ValueError, _xattr, _xdatum, \
23 _xError, _xkwds, _xkwds_not
24# from pygeodesy.fmath import favg # _MODS
25# from pygeodesy.formy import antipode, compassAngle, cosineAndoyerLambert_, \
26# cosineForsytheAndoyerLambert_, cosineLaw, \
27# equirectangular, euclidean, flatLocal_, \
28# flatPolar, _hartzell, haversine, isantipode, \
29# _isequalTo, isnormal, normal, philam2n_xyz, \
30# thomas_, vincentys # as _formy
31from pygeodesy.interns import NN, _COMMASPACE_, _concentric_, _height_, \
32 _intersection_, _LatLon_, _m_, _negative_, \
33 _no_, _overlap_, _too_, _point_ # PYCHOK used!
34# from pygeodesy.iters import PointsIter, points2 # from .vector3d, _MODS
35# from pygeodesy.karney import Caps # _MODS
36from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
37# from pygeodesy.ltp import Ltp, _xLtp # _MODS
38from pygeodesy.named import _NamedBase, notImplemented, notOverloaded, Fmt
39from pygeodesy.namedTuples import Bounds2Tuple, LatLon2Tuple, PhiLam2Tuple, \
40 Trilaterate5Tuple
41# from pygeodesy.nvectorBase import _N_vector_ # _MODS
42from pygeodesy.props import deprecated_method, Property, Property_RO, \
43 property_RO, _update_all
44# from pygeodesy.streprs import Fmt, hstr # from .named, _MODS
45from pygeodesy.units import _isDegrees, _isRadius, Distance_, Lat, Lon, \
46 Height, Radius, Radius_, Scalar, Scalar_
47from pygeodesy.utily import _unrollon, _unrollon3, _Wrap
48from pygeodesy.vector2d import _circin6, Circin6Tuple, _circum3, circum4_, \
49 Circum3Tuple, _radii11ABC
50from pygeodesy.vector3d import nearestOn6, Vector3d, PointsIter
52from contextlib import contextmanager
53from math import asin, cos, degrees, fabs, radians
55__all__ = _ALL_LAZY.latlonBase
56__version__ = '23.12.14'
59class LatLonBase(_NamedBase):
60 '''(INTERNAL) Base class for C{LatLon} points on spherical or
61 ellipsoidal earth models.
62 '''
63 _clipid = INT0 # polygonal clip, see .booleans
64 _datum = None # L{Datum}, to be overriden
65 _height = INT0 # height (C{meter}), default
66 _lat = 0 # latitude (C{degrees})
67 _lon = 0 # longitude (C{degrees})
69 def __init__(self, latlonh, lon=None, height=0, wrap=False, name=NN, datum=None):
70 '''New C{LatLon}.
72 @arg latlonh: Latitude (C{degrees} or DMS C{str} with N or S suffix) or
73 a previous C{LatLon} instance provided C{B{lon}=None}.
74 @kwarg lon: Longitude (C{degrees} or DMS C{str} with E or W suffix) or
75 C(None), indicating B{C{latlonh}} is a C{LatLon}.
76 @kwarg height: Optional height above (or below) the earth surface
77 (C{meter}, conventionally).
78 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}}
79 (C{bool}).
80 @kwarg name: Optional name (C{str}).
81 @kwarg datum: Optional datum (L{Datum}, L{Ellipsoid}, L{Ellipsoid2},
82 L{a_f2Tuple} or I{scalar} radius) or C{None}.
84 @return: New instance (C{LatLon}).
86 @raise RangeError: A B{C{lon}} or C{lat} value outside the valid
87 range and L{rangerrors} set to C{True}.
89 @raise TypeError: If B{C{latlonh}} is not a C{LatLon}.
91 @raise UnitError: Invalid B{C{lat}}, B{C{lon}} or B{C{height}}.
92 '''
93 if name:
94 self.name = name
96 if lon is None:
97 lat, lon, height = _latlonheight3(latlonh, height, wrap)
98 elif wrap:
99 lat, lon = _Wrap.latlonDMS2(latlonh, lon)
100 else:
101 lat = latlonh
103 self._lat = Lat(lat) # parseDMS2(lat, lon)
104 self._lon = Lon(lon) # PYCHOK LatLon2Tuple
105 if height: # elevation
106 self._height = Height(height)
107 if datum is not None:
108 self._datum = _spherical_datum(datum, name=self.name)
110 def __eq__(self, other):
111 return self.isequalTo(other)
113 def __ne__(self, other):
114 return not self.isequalTo(other)
116 def __str__(self):
117 return self.toStr(form=F_D, prec=6)
119 def antipode(self, height=None):
120 '''Return the antipode, the point diametrically opposite to
121 this point.
123 @kwarg height: Optional height of the antipode (C{meter}),
124 this point's height otherwise.
126 @return: The antipodal point (C{LatLon}).
127 '''
128 a = self._formy.antipode(*self.latlon)
129 h = self._heigHt(height)
130 return self.classof(*a, height=h)
132 @deprecated_method
133 def bounds(self, wide, tall, radius=R_M): # PYCHOK no cover
134 '''DEPRECATED, use method C{boundsOf}.'''
135 return self.boundsOf(wide, tall, radius=radius)
137 def boundsOf(self, wide, tall, radius=R_M, height=None):
138 '''Return the SW and NE lat-/longitude of a great circle
139 bounding box centered at this location.
141 @arg wide: Longitudinal box width (C{meter}, same units as
142 B{C{radius}} or C{degrees} if B{C{radius}} is C{None}).
143 @arg tall: Latitudinal box size (C{meter}, same units as
144 B{C{radius}} or C{degrees} if B{C{radius}} is C{None}).
145 @kwarg radius: Mean earth radius (C{meter}) or C{None} if I{both}
146 B{C{wide}} and B{C{tall}} are in C{degrees}.
147 @kwarg height: Height for C{latlonSW} and C{latlonNE} (C{meter}),
148 overriding the point's height.
150 @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)}, the
151 lower-left and upper-right corner (C{LatLon}).
153 @see: U{https://www.Movable-Type.co.UK/scripts/latlong-db.html}
154 '''
155 w = Scalar_(wide=wide) * _0_5
156 t = Scalar_(tall=tall) * _0_5
157 if radius is not None:
158 r = Radius_(radius)
159 c = cos(self.phi)
160 w = degrees(asin(w / r) / c) if fabs(c) > EPS0 else _0_0 # XXX
161 t = degrees(t / r)
162 y, t = self.lat, fabs(t)
163 x, w = self.lon, fabs(w)
165 h = self._heigHt(height)
166 sw = self.classof(y - t, x - w, height=h)
167 ne = self.classof(y + t, x + w, height=h)
168 return Bounds2Tuple(sw, ne, name=self.name)
170 def chordTo(self, other, height=None, wrap=False):
171 '''Compute the length of the chord through the earth between
172 this and an other point.
174 @arg other: The other point (C{LatLon}).
175 @kwarg height: Overriding height for both points (C{meter})
176 or C{None} for each point's height.
177 @kwarg wrap: If C{True}, wrap or I{normalize} the B{C{other}}
178 point (C{bool}).
180 @return: The chord length (conventionally C{meter}).
182 @raise TypeError: The B{C{other}} point is not C{LatLon}.
183 '''
184 def _v3d(ll):
185 t = ll.toEcef(height=height) # .toVector(Vector=Vector3d)
186 return Vector3d(t.x, t.y, t.z)
188 p = self.others(other)
189 if wrap:
190 p = _Wrap.point(p)
191 return _v3d(self).minus(_v3d(p)).length
193 def circin6(self, point2, point3, eps=EPS4, wrap=False):
194 '''Return the radius and center of the I{inscribed} aka I{In-}circle
195 of the (planar) triangle formed by this and two other points.
197 @arg point2: Second point (C{LatLon}).
198 @arg point3: Third point (C{LatLon}).
199 @kwarg eps: Tolerance for function L{pygeodesy.trilaterate3d2}.
200 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{point2}} and
201 B{C{point3}} (C{bool}).
203 @return: L{Circin6Tuple}C{(radius, center, deltas, cA, cB, cC)}. The
204 C{center} and contact points C{cA}, C{cB} and C{cC}, each an
205 instance of this (sub-)class, are co-planar with this and the
206 two given points, see the B{Note} below.
208 @raise ImportError: Package C{numpy} not found, not installed or older
209 than version 1.10.
211 @raise IntersectionError: Near-coincident or -colinear points or
212 a trilateration or C{numpy} issue.
214 @raise TypeError: Invalid B{C{point2}} or B{C{point3}}.
216 @note: The C{center} is trilaterated in cartesian (ECEF) space and converted
217 back to geodetic lat-, longitude and height. The latter, conventionally
218 in C{meter} indicates whether the C{center} is above, below or on the
219 surface of the earth model. If C{deltas} is C{None}, the C{center} is
220 I{un}ambigous. Otherwise C{deltas} is a L{LatLon3Tuple}C{(lat, lon,
221 height)} representing the differences between both results from
222 L{pygeodesy.trilaterate3d2} and C{center} is the mean thereof.
224 @see: Function L{pygeodesy.circin6}, method L{circum3}, U{Incircle
225 <https://MathWorld.Wolfram.com/Incircle.html>} and U{Contact Triangle
226 <https://MathWorld.Wolfram.com/ContactTriangle.html>}.
227 '''
228 with _toCartesian3(self, point2, point3, wrap) as cs:
229 r, c, d, cA, cB, cC = _circin6(*cs, eps=eps, useZ=True, dLL3=True,
230 datum=self.datum) # PYCHOK unpack
231 return Circin6Tuple(r, c.toLatLon(), d, cA.toLatLon(), cB.toLatLon(), cC.toLatLon())
233 def circum3(self, point2, point3, circum=True, eps=EPS4, wrap=False):
234 '''Return the radius and center of the smallest circle I{through} or I{containing}
235 this and two other points.
237 @arg point2: Second point (C{LatLon}).
238 @arg point3: Third point (C{LatLon}).
239 @kwarg circum: If C{True} return the C{circumradius} and C{circumcenter},
240 always, ignoring the I{Meeus}' Type I case (C{bool}).
241 @kwarg eps: Tolerance for function L{pygeodesy.trilaterate3d2}.
242 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{point2}} and
243 B{C{point3}} (C{bool}).
245 @return: A L{Circum3Tuple}C{(radius, center, deltas)}. The C{center}, an
246 instance of this (sub-)class, is co-planar with this and the two
247 given points. If C{deltas} is C{None}, the C{center} is
248 I{un}ambigous. Otherwise C{deltas} is a L{LatLon3Tuple}C{(lat,
249 lon, height)} representing the difference between both results
250 from L{pygeodesy.trilaterate3d2} and C{center} is the mean thereof.
252 @raise ImportError: Package C{numpy} not found, not installed or older than
253 version 1.10.
255 @raise IntersectionError: Near-concentric, -coincident or -colinear points,
256 incompatible C{Ecef} classes or a trilateration
257 or C{numpy} issue.
259 @raise TypeError: Invalid B{C{point2}} or B{C{point3}}.
261 @note: The C{center} is trilaterated in cartesian (ECEF) space and converted
262 back to geodetic lat-, longitude and height. The latter, conventionally
263 in C{meter} indicates whether the C{center} is above, below or on the
264 surface of the earth model. If C{deltas} is C{None}, the C{center} is
265 I{un}ambigous. Otherwise C{deltas} is a L{LatLon3Tuple}C{(lat, lon,
266 height)} representing the difference between both results from
267 L{pygeodesy.trilaterate3d2} and C{center} is the mean thereof.
269 @see: Function L{pygeodesy.circum3} and methods L{circin6} and L{circum4_}.
270 '''
271 with _toCartesian3(self, point2, point3, wrap, circum=circum) as cs:
272 r, c, d = _circum3(*cs, circum=circum, eps=eps, useZ=True, dLL3=True, # XXX -3d2
273 clas=cs[0].classof, datum=self.datum) # PYCHOK unpack
274 return Circum3Tuple(r, c.toLatLon(), d)
276 def circum4_(self, *points, **wrap):
277 '''Best-fit a sphere through this and two or more other points.
279 @arg points: The other points (each a C{LatLon}).
280 @kwarg wrap: If C{True}, wrap or I{normalize} the B{C{points}}
281 (C{bool}), default C{False}.
283 @return: L{Circum4Tuple}C{(radius, center, rank, residuals)} with C{center}
284 an instance of this (sub-)class.
286 @raise ImportError: Package C{numpy} not found, not installed or older than
287 version 1.10.
289 @raise NumPyError: Some C{numpy} issue.
291 @raise TypeError: One of the B{C{points}} invalid.
293 @raise ValueError: Too few B{C{points}}.
295 @see: Function L{pygeodesy.circum4_} and L{circum3}.
296 '''
297 def _cs(ps, C, wrap=False):
298 _wp = _Wrap.point if wrap else (lambda p: p)
299 for i, p in enumerate(ps):
300 yield C(i=i, points=_wp(p))
302 C = self._toCartesianEcef
303 c = C(point=self)
304 t = circum4_(c, Vector=c.classof, *_cs(points, C, **wrap))
305 c = t.center.toLatLon(LatLon=self.classof)
306 return t.dup(center=c)
308 @property
309 def clipid(self):
310 '''Get the (polygonal) clip (C{int}).
311 '''
312 return self._clipid
314 @clipid.setter # PYCHOK setter!
315 def clipid(self, clipid):
316 '''Get the (polygonal) clip (C{int}).
317 '''
318 self._clipid = int(clipid)
320 @deprecated_method
321 def compassAngle(self, other, **adjust_wrap): # PYCHOK no cover
322 '''DEPRECATED, use method L{compassAngleTo}.'''
323 return self.compassAngleTo(other, **adjust_wrap)
325 def compassAngleTo(self, other, **adjust_wrap):
326 '''Return the angle from North for the direction vector between
327 this and an other point.
329 Suitable only for short, non-near-polar vectors up to a few
330 hundred Km or Miles. Use method C{initialBearingTo} for
331 larger distances.
333 @arg other: The other point (C{LatLon}).
334 @kwarg adjust_wrap: Optional keyword arguments for function
335 L{pygeodesy.compassAngle}.
337 @return: Compass angle from North (C{degrees360}).
339 @raise TypeError: The B{C{other}} point is not C{LatLon}.
341 @note: Courtesy of Martin Schultz.
343 @see: U{Local, flat earth approximation
344 <https://www.EdWilliams.org/avform.htm#flat>}.
345 '''
346 p = self.others(other)
347 return self._formy.compassAngle(self.lat, self.lon, p.lat, p.lon, **adjust_wrap)
349 def cosineAndoyerLambertTo(self, other, wrap=False):
350 '''Compute the distance between this and an other point using the U{Andoyer-Lambert correction<https://
351 navlib.net/wp-content/uploads/2013/10/admiralty-manual-of-navigation-vol-1-1964-english501c.pdf>}
352 of the U{Law of Cosines<https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>} formula.
354 @arg other: The other point (C{LatLon}).
355 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
356 the B{C{other}} point (C{bool}).
358 @return: Distance (C{meter}, same units as the axes of this
359 point's datum ellipsoid).
361 @raise TypeError: The B{C{other}} point is not C{LatLon}.
363 @see: Function L{pygeodesy.cosineAndoyerLambert} and methods
364 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo},
365 C{distanceTo*}, L{equirectangularTo}, L{euclideanTo},
366 L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo}, L{haversineTo},
367 L{thomasTo} and L{vincentysTo}.
368 '''
369 return self._distanceTo_(self._formy.cosineAndoyerLambert_, other, wrap=wrap)
371 def cosineForsytheAndoyerLambertTo(self, other, wrap=False):
372 '''Compute the distance between this and an other point using
373 the U{Forsythe-Andoyer-Lambert correction
374 <https://www2.UNB.Ca/gge/Pubs/TR77.pdf>} of the U{Law of Cosines
375 <https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>}
376 formula.
378 @arg other: The other point (C{LatLon}).
379 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
380 the B{C{other}} point (C{bool}).
382 @return: Distance (C{meter}, same units as the axes of
383 this point's datum ellipsoid).
385 @raise TypeError: The B{C{other}} point is not C{LatLon}.
387 @see: Function L{pygeodesy.cosineForsytheAndoyerLambert} and methods
388 L{cosineAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
389 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
390 L{flatPolarTo}, L{haversineTo}, L{thomasTo} and L{vincentysTo}.
391 '''
392 return self._distanceTo_(self._formy.cosineForsytheAndoyerLambert_, other, wrap=wrap)
394 def cosineLawTo(self, other, radius=None, wrap=False):
395 '''Compute the distance between this and an other point using the
396 U{spherical Law of Cosines
397 <https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>}
398 formula.
400 @arg other: The other point (C{LatLon}).
401 @kwarg radius: Mean earth radius (C{meter}) or C{None}
402 for the mean radius of this point's datum
403 ellipsoid.
404 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
405 the B{C{other}} point (C{bool}).
407 @return: Distance (C{meter}, same units as B{C{radius}}).
409 @raise TypeError: The B{C{other}} point is not C{LatLon}.
411 @see: Function L{pygeodesy.cosineLaw} and methods L{cosineAndoyerLambertTo},
412 L{cosineForsytheAndoyerLambertTo}, C{distanceTo*}, L{equirectangularTo},
413 L{euclideanTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},
414 L{haversineTo}, L{thomasTo} and L{vincentysTo}.
415 '''
416 return self._distanceTo(self._formy.cosineLaw, other, radius, wrap=wrap)
418 @property_RO
419 def datum(self): # PYCHOK no cover
420 '''I{Must be overloaded}.'''
421 notOverloaded(self)
423 def destinationXyz(self, delta, LatLon=None, **LatLon_kwds):
424 '''Calculate the destination using a I{local} delta from this point.
426 @arg delta: Local delta to the destination (L{XyzLocal}, L{Enu},
427 L{Ned} or L{Local9Tuple}).
428 @kwarg LatLon: Optional (geodetic) class to return the destination
429 or C{None}.
430 @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
431 arguments, ignored if C{B{LatLon} is None}.
433 @return: Destination as a C{B{LatLon}(lat, lon, **B{LatLon_kwds})}
434 instance or if C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat,
435 lon, height)} respectively L{LatLon4Tuple}C{(lat, lon,
436 height, datum)} depending on whether a C{datum} keyword
437 is un-/specified.
439 @raise TypeError: Invalid B{C{delta}}, B{C{LatLon}} or B{C{LatLon_kwds}}.
440 '''
441 t = self._Ltp._local2ecef(delta, nine=True)
442 return t.toLatLon(LatLon=LatLon, **_xkwds(LatLon_kwds, name=self.name))
444 def _distanceTo(self, func, other, radius=None, **kwds):
445 '''(INTERNAL) Helper for distance methods C{<func>To}.
446 '''
447 p, r = self.others(other, up=2), radius
448 if r is None:
449 r = self._datum.ellipsoid.R1 if self._datum else R_M
450 return func(self.lat, self.lon, p.lat, p.lon, radius=r, **kwds)
452 def _distanceTo_(self, func_, other, wrap=False, radius=None):
453 '''(INTERNAL) Helper for (ellipsoidal) distance methods C{<func>To}.
454 '''
455 p = self.others(other, up=2)
456 D = self.datum
457 lam21, phi2, _ = _Wrap.philam3(self.lam, p.phi, p.lam, wrap)
458 r = func_(phi2, self.phi, lam21, datum=D)
459 return r * (D.ellipsoid.a if radius is None else radius)
461 @property_RO
462 def Ecef(self):
463 '''Get the ECEF I{class} (L{EcefKarney}), I{once}.
464 '''
465 LatLonBase.Ecef = E = _MODS.ecef.EcefKarney # overwrite property_RO
466 return E
468 @Property_RO
469 def _Ecef_forward(self):
470 '''(INTERNAL) Helper for L{_ecef9} and L{toEcef} (C{callable}).
471 '''
472 return self.Ecef(self.datum, name=self.name).forward
474 @Property_RO
475 def _ecef9(self):
476 '''(INTERNAL) Helper for L{toCartesian}, L{toEcef} and L{toCartesian} (L{Ecef9Tuple}).
477 '''
478 return self._Ecef_forward(self, M=True)
480 @property_RO
481 def ellipsoidalLatLon(self):
482 '''Get the C{LatLon type} iff ellipsoidal, overloaded in L{LatLonEllipsoidalBase}.
483 '''
484 return False
486 @deprecated_method
487 def equals(self, other, eps=None): # PYCHOK no cover
488 '''DEPRECATED, use method L{isequalTo}.'''
489 return self.isequalTo(other, eps=eps)
491 @deprecated_method
492 def equals3(self, other, eps=None): # PYCHOK no cover
493 '''DEPRECATED, use method L{isequalTo3}.'''
494 return self.isequalTo3(other, eps=eps)
496 def equirectangularTo(self, other, **radius_adjust_limit_wrap):
497 '''Compute the distance between this and an other point
498 using the U{Equirectangular Approximation / Projection
499 <https://www.Movable-Type.co.UK/scripts/latlong.html#equirectangular>}.
501 Suitable only for short, non-near-polar distances up to a
502 few hundred Km or Miles. Use method L{haversineTo} or
503 C{distanceTo*} for more accurate and/or larger distances.
505 @arg other: The other point (C{LatLon}).
506 @kwarg radius_adjust_limit_wrap: Optional keyword arguments
507 for function L{pygeodesy.equirectangular},
508 overriding the default mean C{radius} of this
509 point's datum ellipsoid.
511 @return: Distance (C{meter}, same units as B{C{radius}}).
513 @raise TypeError: The B{C{other}} point is not C{LatLon}.
515 @see: Function L{pygeodesy.equirectangular} and methods L{cosineAndoyerLambertTo},
516 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
517 C{euclideanTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},
518 L{haversineTo}, L{thomasTo} and L{vincentysTo}.
519 '''
520 return self._distanceTo(self._formy.equirectangular, other, **radius_adjust_limit_wrap)
522 def euclideanTo(self, other, **radius_adjust_wrap):
523 '''Approximate the C{Euclidian} distance between this and
524 an other point.
526 See function L{pygeodesy.euclidean} for the available B{C{options}}.
528 @arg other: The other point (C{LatLon}).
529 @kwarg radius_adjust_wrap: Optional keyword arguments for function
530 L{pygeodesy.euclidean}, overriding the default mean
531 C{radius} of this point's datum ellipsoid.
533 @return: Distance (C{meter}, same units as B{C{radius}}).
535 @raise TypeError: The B{C{other}} point is not C{LatLon}.
537 @see: Function L{pygeodesy.euclidean} and methods L{cosineAndoyerLambertTo},
538 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
539 L{equirectangularTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},
540 L{haversineTo}, L{thomasTo} and L{vincentysTo}.
541 '''
542 return self._distanceTo(self._formy.euclidean, other, **radius_adjust_wrap)
544 def flatLocalTo(self, other, radius=None, wrap=False):
545 '''Compute the distance between this and an other point using the
546 U{ellipsoidal Earth to plane projection
547 <https://WikiPedia.org/wiki/Geographical_distance#Ellipsoidal_Earth_projected_to_a_plane>}
548 aka U{Hubeny<https://www.OVG.AT/de/vgi/files/pdf/3781/>} formula.
550 @arg other: The other point (C{LatLon}).
551 @kwarg radius: Mean earth radius (C{meter}) or C{None} for
552 the I{equatorial radius} of this point's
553 datum ellipsoid.
554 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
555 the B{C{other}} point (C{bool}).
557 @return: Distance (C{meter}, same units as B{C{radius}}).
559 @raise TypeError: The B{C{other}} point is not C{LatLon}.
561 @raise ValueError: Invalid B{C{radius}}.
563 @see: Function L{pygeodesy.flatLocal}/L{pygeodesy.hubeny}, methods
564 L{cosineAndoyerLambertTo}, L{cosineForsytheAndoyerLambertTo},
565 L{cosineLawTo}, C{distanceTo*}, L{equirectangularTo}, L{euclideanTo},
566 L{flatPolarTo}, L{haversineTo}, L{thomasTo} and L{vincentysTo} and
567 U{local, flat Earth approximation<https://www.edwilliams.org/avform.htm#flat>}.
568 '''
569 return self._distanceTo_(self._formy.flatLocal_, other, wrap=wrap, radius=
570 radius if radius in (None, R_M, _1_0, 1) else Radius(radius)) # PYCHOK kwargs
572 hubenyTo = flatLocalTo # for Karl Hubeny
574 def flatPolarTo(self, other, **radius_wrap):
575 '''Compute the distance between this and an other point using
576 the U{polar coordinate flat-Earth<https://WikiPedia.org/wiki/
577 Geographical_distance#Polar_coordinate_flat-Earth_formula>} formula.
579 @arg other: The other point (C{LatLon}).
580 @kwarg radius_wrap: Optional keyword arguments for function
581 L{pygeodesy.flatPolar}, overriding the
582 default mean C{radius} of this point's
583 datum ellipsoid.
585 @return: Distance (C{meter}, same units as B{C{radius}}).
587 @raise TypeError: The B{C{other}} point is not C{LatLon}.
589 @see: Function L{pygeodesy.flatPolar} and methods L{cosineAndoyerLambertTo},
590 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
591 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
592 L{haversineTo}, L{thomasTo} and L{vincentysTo}.
593 '''
594 return self._distanceTo(self._formy.flatPolar, other, **radius_wrap)
596 @property_RO
597 def _formy(self):
598 '''(INTERNAL) Import module C{distance.formy}, I{once} and I{lazily}
599 to avoid circular imports.
600 '''
601 LatLonBase._formy = f = _MODS.formy # overwrite property_RO
602 return f
604 def hartzell(self, los=None, earth=None):
605 '''Compute the intersection of a Line-Of-Sight (los) from this Point-Of-View
606 (pov) with this point's ellipsoid surface.
608 @kwarg los: Line-Of-Sight, I{direction} to earth (L{Los}, L{Vector3d})
609 or C{None} to point to the ellipsoid's center.
610 @kwarg earth: The earth model (L{Datum}, L{Ellipsoid}, L{Ellipsoid2},
611 L{a_f2Tuple} or C{scalar} radius in C{meter}) overriding
612 this point's C{datum} ellipsoid.
614 @return: The ellipsoid intersection (C{LatLon}) with C{.height} set
615 to the distance to this C{pov}.
617 @raise IntersectionError: Null or bad C{pov} or B{C{los}}, this C{pov}
618 is inside the ellipsoid or B{C{los}} points
619 outside or away from the ellipsoid.
621 @raise TypeError: Invalid B{C{los}}.
623 @see: Function C{hartzell} for further details.
624 '''
625 return self._formy._hartzell(self, los, earth, LatLon=self.classof)
627 def haversineTo(self, other, **radius_wrap):
628 '''Compute the distance between this and an other point using the
629 U{Haversine<https://www.Movable-Type.co.UK/scripts/latlong.html>}
630 formula.
632 @arg other: The other point (C{LatLon}).
633 @kwarg radius_wrap: Optional keyword arguments for function
634 L{pygeodesy.haversine}, overriding the
635 default mean C{radius} of this point's
636 datum ellipsoid.
638 @return: Distance (C{meter}, same units as B{C{radius}}).
640 @raise TypeError: The B{C{other}} point is not C{LatLon}.
642 @see: Function L{pygeodesy.haversine} and methods L{cosineAndoyerLambertTo},
643 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
644 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
645 L{flatPolarTo}, L{thomasTo} and L{vincentysTo}.
646 '''
647 return self._distanceTo(self._formy.haversine, other, **radius_wrap)
649 def _havg(self, other, f=_0_5, h=None):
650 '''(INTERNAL) Weighted, average height.
652 @arg other: An other point (C{LatLon}).
653 @kwarg f: Optional fraction (C{float}).
654 @kwarg h: Overriding height (C{meter}).
656 @return: Average, fractional height (C{float}) or
657 the overriding B{C{height}} (C{Height}).
658 '''
659 return Height(h) if h is not None else \
660 _MODS.fmath.favg(self.height, other.height, f=f)
662 @Property
663 def height(self):
664 '''Get the height (C{meter}).
665 '''
666 return self._height
668 @height.setter # PYCHOK setter!
669 def height(self, height):
670 '''Set the height (C{meter}).
672 @raise TypeError: Invalid B{C{height}} C{type}.
674 @raise ValueError: Invalid B{C{height}}.
675 '''
676 h = Height(height)
677 if self._height != h:
678 _update_all(self)
679 self._height = h
681 def _heigHt(self, height):
682 '''(INTERNAL) Overriding this C{height}.
683 '''
684 return self.height if height is None else Height(height)
686 def height4(self, earth=None, normal=True, LatLon=None, **LatLon_kwds):
687 '''Compute the height above or below and the projection of this point
688 on this datum's or on an other earth's ellipsoid surface.
690 @kwarg earth: A datum, ellipsoid, triaxial ellipsoid or earth radius
691 I{overriding} this datum (L{Datum}, L{Ellipsoid},
692 L{Ellipsoid2}, L{a_f2Tuple}, L{Triaxial}, L{Triaxial_},
693 L{JacobiConformal} or C{meter}, conventionally).
694 @kwarg normal: If C{True} the projection is the nearest point on the
695 ellipsoid's surface, otherwise the intersection of the
696 radial line to the center and the ellipsoid's surface.
697 @kwarg LatLon: Optional class to return the height and projection
698 (C{LatLon}) or C{None}.
699 @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,
700 ignored if C{B{LatLon} is None}.
702 @note: Use keyword argument C{height=0} to override C{B{LatLon}.height}
703 to {0} or any other C{scalar}, conventionally in C{meter}.
705 @return: An instance of B{C{LatLon}} or if C{B{LatLon} is None}, a
706 L{Vector4Tuple}C{(x, y, z, h)} with the I{projection} C{x}, C{y}
707 and C{z} coordinates and height C{h} in C{meter}, conventionally.
709 @raise TriaxialError: No convergence in triaxial root finding.
711 @raise TypeError: Invalid B{C{earth}}.
713 @see: L{Ellipsoid.height4} and L{Triaxial_.height4} for more information.
714 '''
715 c = self.toCartesian()
716 if LatLon is None:
717 r = c.height4(earth=earth, normal=normal)
718 else:
719 r = c.height4(earth=earth, normal=normal, Cartesian=c.classof, height=0)
720 r = r.toLatLon(LatLon=LatLon, **_xkwds(LatLon_kwds, height=r.height))
721 return r
723 def heightStr(self, prec=-2, m=_m_):
724 '''Return this point's B{C{height}} as C{str}ing.
726 @kwarg prec: Number of (decimal) digits, unstripped (C{int}).
727 @kwarg m: Optional unit of the height (C{str}).
729 @see: Function L{pygeodesy.hstr}.
730 '''
731 return _MODS.streprs.hstr(self.height, prec=prec, m=m)
733 def intersecant2(self, *args, **kwds): # PYCHOK no cover
734 '''B{Not implemented}, throws a C{NotImplementedError} always.'''
735 notImplemented(self, *args, **kwds)
737 def _intersecend2(self, p, q, wrap, height, g_or_r, P, Q, unused): # in .LatLonEllipsoidalBaseDI.intersecant2
738 '''(INTERNAL) Interpolate 2 heights along a geodesic or rhumb
739 line and return the 2 intercant points accordingly.
740 '''
741 if height is None:
742 hp = hq = _xattr(p, height=INT0)
743 h = _xattr(q, height=hp) # if isLatLon(q) else hp
744 if h != hp:
745 s = g_or_r._Inverse(p, q, wrap).s12
746 if s: # fmath.fidw?
747 s = (h - hp) / s # slope
748 hq += s * Q.s12
749 hp += s * P.s12
750 else:
751 hp = hq = _MODS.fmath.favg(hp, h)
752 else:
753 hp = hq = Height(height)
755# n = self.name or unused.__name__
756 p = q = self.classof(P.lat2, P.lon2, datum=g_or_r.datum, height=hp) # name=n
757 p._iteration = P.iteration
758 if P is not Q:
759 q = self.classof(Q.lat2, Q.lon2, datum=g_or_r.datum, height=hq) # name=n
760 q._iteration = Q.iteration
761 return p, q
763 @deprecated_method
764 def isantipode(self, other, eps=EPS): # PYCHOK no cover
765 '''DEPRECATED, use method L{isantipodeTo}.'''
766 return self.isantipodeTo(other, eps=eps)
768 def isantipodeTo(self, other, eps=EPS):
769 '''Check whether this and an other point are antipodal,
770 on diametrically opposite sides of the earth.
772 @arg other: The other point (C{LatLon}).
773 @kwarg eps: Tolerance for near-equality (C{degrees}).
775 @return: C{True} if points are antipodal within the given
776 tolerance, C{False} otherwise.
777 '''
778 p = self.others(other)
779 return self._formy.isantipode(*(self.latlon + p.latlon), eps=eps)
781 @Property_RO
782 def isEllipsoidal(self):
783 '''Check whether this point is ellipsoidal (C{bool} or C{None} if unknown).
784 '''
785 return self.datum.isEllipsoidal if self._datum else None
787 def isequalTo(self, other, eps=None):
788 '''Compare this point with an other point, I{ignoring} height.
790 @arg other: The other point (C{LatLon}).
791 @kwarg eps: Tolerance for equality (C{degrees}).
793 @return: C{True} if both points are identical,
794 I{ignoring} height, C{False} otherwise.
796 @raise TypeError: The B{C{other}} point is not C{LatLon}
797 or mismatch of the B{C{other}} and
798 this C{class} or C{type}.
800 @raise UnitError: Invalid B{C{eps}}.
802 @see: Method L{isequalTo3}.
803 '''
804 return self._formy._isequalTo(self, self.others(other), eps=eps)
806 def isequalTo3(self, other, eps=None):
807 '''Compare this point with an other point, I{including} height.
809 @arg other: The other point (C{LatLon}).
810 @kwarg eps: Tolerance for equality (C{degrees}).
812 @return: C{True} if both points are identical I{including}
813 height, C{False} otherwise.
815 @raise TypeError: The B{C{other}} point is not C{LatLon}
816 or mismatch of the B{C{other}} and this
817 C{class} or C{type}.
819 @see: Method L{isequalTo}.
820 '''
821 return self.height == self.others(other).height and \
822 self._formy._isequalTo(self, other, eps=eps)
824 @Property_RO
825 def isnormal(self):
826 '''Return C{True} if this point is normal (C{bool}),
827 meaning C{abs(lat) <= 90} and C{abs(lon) <= 180}.
829 @see: Methods L{normal}, L{toNormal} and functions L{isnormal
830 <pygeodesy.isnormal>} and L{normal<pygeodesy.normal>}.
831 '''
832 return self._formy.isnormal(self.lat, self.lon, eps=0)
834 @Property_RO
835 def isSpherical(self):
836 '''Check whether this point is spherical (C{bool} or C{None} if unknown).
837 '''
838 return self.datum.isSpherical if self._datum else None
840 @Property_RO
841 def lam(self):
842 '''Get the longitude (B{C{radians}}).
843 '''
844 return radians(self.lon)
846 @Property
847 def lat(self):
848 '''Get the latitude (C{degrees90}).
849 '''
850 return self._lat
852 @lat.setter # PYCHOK setter!
853 def lat(self, lat):
854 '''Set the latitude (C{str[N|S]} or C{degrees}).
856 @raise ValueError: Invalid B{C{lat}}.
857 '''
858 lat = Lat(lat) # parseDMS(lat, suffix=_NS_, clip=90)
859 if self._lat != lat:
860 _update_all(self)
861 self._lat = lat
863 @Property
864 def latlon(self):
865 '''Get the lat- and longitude (L{LatLon2Tuple}C{(lat, lon)}).
866 '''
867 return LatLon2Tuple(self._lat, self._lon, name=self.name)
869 @latlon.setter # PYCHOK setter!
870 def latlon(self, latlonh):
871 '''Set the lat- and longitude and optionally the height
872 (2- or 3-tuple or comma- or space-separated C{str}
873 of C{degrees90}, C{degrees180} and C{meter}).
875 @raise TypeError: Height of B{C{latlonh}} not C{scalar} or
876 B{C{latlonh}} not C{list} or C{tuple}.
878 @raise ValueError: Invalid B{C{latlonh}} or M{len(latlonh)}.
880 @see: Function L{pygeodesy.parse3llh} to parse a B{C{latlonh}}
881 string into a 3-tuple C{(lat, lon, h)}.
882 '''
883 if isstr(latlonh):
884 latlonh = parse3llh(latlonh, height=self.height)
885 else:
886 _xinstanceof(list, tuple, latlonh=latlonh)
887 if len(latlonh) == 3:
888 h = Height(latlonh[2], name=Fmt.SQUARE(latlonh=2))
889 elif len(latlonh) != 2:
890 raise _ValueError(latlonh=latlonh)
891 else:
892 h = self.height
894 llh = Lat(latlonh[0]), Lon(latlonh[1]), h # parseDMS2(latlonh[0], latlonh[1])
895 if (self._lat, self._lon, self._height) != llh:
896 _update_all(self)
897 self._lat, self._lon, self._height = llh
899 def latlon2(self, ndigits=0):
900 '''Return this point's lat- and longitude in C{degrees}, rounded.
902 @kwarg ndigits: Number of (decimal) digits (C{int}).
904 @return: A L{LatLon2Tuple}C{(lat, lon)}, both C{float}
905 and rounded away from zero.
907 @note: The C{round}ed values are always C{float}, also
908 if B{C{ndigits}} is omitted.
909 '''
910 return LatLon2Tuple(round(self.lat, ndigits),
911 round(self.lon, ndigits), name=self.name)
913 @deprecated_method
914 def latlon_(self, ndigits=0): # PYCHOK no cover
915 '''DEPRECATED, use method L{latlon2}.'''
916 return self.latlon2(ndigits=ndigits)
918 latlon2round = latlon_ # PYCHOK no cover
920 @Property
921 def latlonheight(self):
922 '''Get the lat-, longitude and height (L{LatLon3Tuple}C{(lat, lon, height)}).
923 '''
924 return self.latlon.to3Tuple(self.height)
926 @latlonheight.setter # PYCHOK setter!
927 def latlonheight(self, latlonh):
928 '''Set the lat- and longitude and optionally the height
929 (2- or 3-tuple or comma- or space-separated C{str} of
930 C{degrees90}, C{degrees180} and C{meter}).
932 @see: Property L{latlon} for more details.
933 '''
934 self.latlon = latlonh
936 @Property
937 def lon(self):
938 '''Get the longitude (C{degrees180}).
939 '''
940 return self._lon
942 @lon.setter # PYCHOK setter!
943 def lon(self, lon):
944 '''Set the longitude (C{str[E|W]} or C{degrees}).
946 @raise ValueError: Invalid B{C{lon}}.
947 '''
948 lon = Lon(lon) # parseDMS(lon, suffix=_EW_, clip=180)
949 if self._lon != lon:
950 _update_all(self)
951 self._lon = lon
953 @property_RO
954 def _ltp(self):
955 '''(INTERNAL) Get the C{.ltp} module, I{once}.
956 '''
957 LatLonBase._ltp = m = _MODS.ltp # overwrite property_RO
958 return m
960 @Property_RO
961 def _Ltp(self):
962 '''(INTERNAL) Cache for L{toLtp}.
963 '''
964 return self._ltp.Ltp(self, ecef=self.Ecef(self.datum), name=self.name)
966 def nearestOn6(self, points, closed=False, height=None, wrap=False):
967 '''Locate the point on a path or polygon closest to this point.
969 Points are converted to and distances are computed in
970 I{geocentric}, cartesian space.
972 @arg points: The path or polygon points (C{LatLon}[]).
973 @kwarg closed: Optionally, close the polygon (C{bool}).
974 @kwarg height: Optional height, overriding the height of
975 this and all other points (C{meter}). If
976 C{None}, take the height of points into
977 account for distances.
978 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
979 the B{C{points}} (C{bool}).
981 @return: A L{NearestOn6Tuple}C{(closest, distance, fi, j,
982 start, end)} with the C{closest}, the C{start}
983 and the C{end} point each an instance of this
984 C{LatLon} and C{distance} in C{meter}, same
985 units as the cartesian axes.
987 @raise PointsError: Insufficient number of B{C{points}}.
989 @raise TypeError: Some B{C{points}} or some B{C{points}}'
990 C{Ecef} invalid.
992 @raise ValueError: Some B{C{points}}' C{Ecef} is incompatible.
994 @see: Function L{nearestOn6<pygeodesy.nearestOn6>}.
995 '''
996 def _cs(Ps, h, w, C):
997 p = None # not used
998 for i, q in Ps.enumerate():
999 if w and i:
1000 q = _unrollon(p, q)
1001 yield C(height=h, i=i, up=3, points=q)
1002 p = q
1004 C = self._toCartesianEcef # to verify datum and Ecef
1005 Ps = self.PointsIter(points, wrap=wrap)
1007 c = C(height=height, this=self) # this Cartesian
1008 t = nearestOn6(c, _cs(Ps, height, wrap, C), closed=closed)
1009 c, s, e = t.closest, t.start, t.end
1011 kwds = _xkwds_not(None, LatLon=self.classof, # this LatLon
1012 height=height)
1013 _r = self.Ecef(self.datum).reverse
1014 p = _r(c).toLatLon(**kwds)
1015 s = _r(s).toLatLon(**kwds) if s is not c else p
1016 e = _r(e).toLatLon(**kwds) if e is not c else p
1017 return t.dup(closest=p, start=s, end=e)
1019 def nearestTo(self, *args, **kwds): # PYCHOK no cover
1020 '''B{Not implemented}, throws a C{NotImplementedError} always.'''
1021 notImplemented(self, *args, **kwds)
1023 def normal(self):
1024 '''Normalize this point I{in-place} to C{abs(lat) <= 90} and
1025 C{abs(lon) <= 180}.
1027 @return: C{True} if this point was I{normal}, C{False} if it
1028 wasn't (but is now).
1030 @see: Property L{isnormal} and method L{toNormal}.
1031 '''
1032 n = self.isnormal
1033 if not n:
1034 self.latlon = self._formy.normal(*self.latlon)
1035 return n
1037 @property_RO
1038 def _N_vector(self):
1039 '''(INTERNAL) Get the C{Nvector} (C{nvectorBase._N_vector_})
1040 '''
1041 x, y, z = self._n_xyz3
1042 return _MODS.nvectorBase._N_vector_(x, y, z, h=self.height, name=self.name)
1044 @Property_RO
1045 def _n_xyz3(self):
1046 '''(INTERNAL) Get the n-vector components as L{Vector3Tuple}.
1047 '''
1048 return self._formy.philam2n_xyz(self.phi, self.lam, name=self.name)
1050 @Property_RO
1051 def phi(self):
1052 '''Get the latitude (B{C{radians}}).
1053 '''
1054 return radians(self.lat)
1056 @Property_RO
1057 def philam(self):
1058 '''Get the lat- and longitude (L{PhiLam2Tuple}C{(phi, lam)}).
1059 '''
1060 return PhiLam2Tuple(self.phi, self.lam, name=self.name)
1062 def philam2(self, ndigits=0):
1063 '''Return this point's lat- and longitude in C{radians}, rounded.
1065 @kwarg ndigits: Number of (decimal) digits (C{int}).
1067 @return: A L{PhiLam2Tuple}C{(phi, lam)}, both C{float}
1068 and rounded away from zero.
1070 @note: The C{round}ed values are always C{float}, also
1071 if B{C{ndigits}} is omitted.
1072 '''
1073 return PhiLam2Tuple(round(self.phi, ndigits),
1074 round(self.lam, ndigits), name=self.name)
1076 @Property_RO
1077 def philamheight(self):
1078 '''Get the lat-, longitude in C{radians} and height (L{PhiLam3Tuple}C{(phi, lam, height)}).
1079 '''
1080 return self.philam.to3Tuple(self.height)
1082 @deprecated_method
1083 def points(self, points, closed=True): # PYCHOK no cover
1084 '''DEPRECATED, use method L{points2}.'''
1085 return self.points2(points, closed=closed)
1087 def points2(self, points, closed=True):
1088 '''Check a path or polygon represented by points.
1090 @arg points: The path or polygon points (C{LatLon}[])
1091 @kwarg closed: Optionally, consider the polygon closed,
1092 ignoring any duplicate or closing final
1093 B{C{points}} (C{bool}).
1095 @return: A L{Points2Tuple}C{(number, points)}, an C{int}
1096 and C{list} or C{tuple}.
1098 @raise PointsError: Insufficient number of B{C{points}}.
1100 @raise TypeError: Some B{C{points}} are not C{LatLon}.
1101 '''
1102 return _MODS.iters.points2(points, closed=closed, base=self)
1104 def PointsIter(self, points, loop=0, dedup=False, wrap=False):
1105 '''Return a C{PointsIter} iterator.
1107 @arg points: The path or polygon points (C{LatLon}[])
1108 @kwarg loop: Number of loop-back points (non-negative C{int}).
1109 @kwarg dedup: Skip duplicate points (C{bool}).
1110 @kwarg wrap: If C{True}, wrap or I{normalize} the
1111 enum-/iterated B{C{points}} (C{bool}).
1113 @return: A new C{PointsIter} iterator.
1115 @raise PointsError: Insufficient number of B{C{points}}.
1116 '''
1117 return PointsIter(points, base=self, loop=loop, dedup=dedup, wrap=wrap)
1119 def radii11(self, point2, point3, wrap=False):
1120 '''Return the radii of the C{Circum-}, C{In-}, I{Soddy} and C{Tangent}
1121 circles of a (planar) triangle formed by this and two other points.
1123 @arg point2: Second point (C{LatLon}).
1124 @arg point3: Third point (C{LatLon}).
1125 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{point2}} and
1126 B{C{point3}} (C{bool}).
1128 @return: L{Radii11Tuple}C{(rA, rB, rC, cR, rIn, riS, roS, a, b, c, s)}.
1130 @raise IntersectionError: Near-coincident or -colinear points.
1132 @raise TypeError: Invalid B{C{point2}} or B{C{point3}}.
1134 @see: Function L{pygeodesy.radii11}, U{Incircle
1135 <https://MathWorld.Wolfram.com/Incircle.html>}, U{Soddy Circles
1136 <https://MathWorld.Wolfram.com/SoddyCircles.html>} and U{Tangent
1137 Circles<https://MathWorld.Wolfram.com/TangentCircles.html>}.
1138 '''
1139 with _toCartesian3(self, point2, point3, wrap) as cs:
1140 return _radii11ABC(*cs, useZ=True)[0]
1142 def _rhumb3(self, exact, radius): # != .sphericalBase._rhumbs3
1143 '''(INTERNAL) Get the C{rhumb} for this point's datum or for
1144 the B{C{radius}}' earth model iff non-C{None}.
1145 '''
1146 try:
1147 d = self._rhumb3dict
1148 t = d[(exact, radius)]
1149 except KeyError:
1150 D = self.datum if radius is None else \
1151 _spherical_datum(radius) # ellipsoidal OK
1152 try:
1153 r = D.ellipsoid.rhumb_(exact=exact) # or D.isSpherical
1154 except AttributeError as x:
1155 raise _AttributeError(datum=D, radius=radius, cause=x)
1156 t = r, D, _MODS.karney.Caps
1157 while d:
1158 d.popitem()
1159 d[(exact, radius)] = t # cache 3-tuple
1160 return t
1162 @Property_RO
1163 def _rhumb3dict(self): # in rhumbIntersecant2 below
1164 return {} # single-item cache
1166 def rhumbAzimuthTo(self, other, exact=False, radius=None, wrap=False, b360=False):
1167 '''Return the azimuth (bearing) of a rhumb line (loxodrome) between this
1168 and an other (ellipsoidal) point.
1170 @arg other: The other point (C{LatLon}).
1171 @kwarg exact: Exact C{Rhumb...} to use (C{bool} or C{Rhumb...}), see
1172 method L{Ellipsoid.rhumb_}.
1173 @kwarg radius: Optional earth radius (C{meter}) or earth model (L{Datum},
1174 L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}), overriding
1175 this point's datum.
1176 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{other}}
1177 point (C{bool}).
1178 @kwarg b360: If C{True}, return the azimuth in the bearing range.
1180 @return: Rhumb azimuth (compass C{degrees180} or C{degrees360}).
1182 @raise TypeError: The B{C{other}} point is incompatible or B{C{radius}}
1183 is invalid.
1184 '''
1185 r, _, Cs = self._rhumb3(exact, radius)
1186 z = r._Inverse(self, other, wrap, outmask=Cs.AZIMUTH).azi12
1187 return _umod_360(z + _360_0) if b360 else z
1189 def rhumbDestination(self, distance, azimuth, exact=False, radius=None, height=None):
1190 '''Return the destination point having travelled the given distance from
1191 this point along a rhumb line (loxodrome) of the given azimuth.
1193 @arg distance: Distance travelled (C{meter}, same units as this point's
1194 datum (ellipsoid) axes or B{C{radius}}, may be negative.
1195 @arg azimuth: Azimuth (bearing) of the rhumb line (compass C{degrees}).
1196 @kwarg exact: Exact C{Rhumb...} to use (C{bool} or C{Rhumb...}), see
1197 method L{Ellipsoid.rhumb_}.
1198 @kwarg radius: Optional earth radius (C{meter}) or earth model (L{Datum},
1199 L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}), overriding
1200 this point's datum.
1201 @kwarg height: Optional height, overriding the default height (C{meter}).
1203 @return: The destination point (ellipsoidal C{LatLon}).
1205 @raise TypeError: Invalid B{C{radius}}.
1207 @raise ValueError: Invalid B{C{distance}}, B{C{azimuth}}, B{C{radius}}
1208 or B{C{height}}.
1209 '''
1210 r, D, _ = self._rhumb3(exact, radius)
1211 d = r._Direct(self, azimuth, distance)
1212 h = self._heigHt(height)
1213 return self.classof(d.lat2, d.lon2, datum=D, height=h)
1215 def rhumbDistanceTo(self, other, exact=False, radius=None, wrap=False):
1216 '''Return the distance from this to an other point along a rhumb line
1217 (loxodrome).
1219 @arg other: The other point (C{LatLon}).
1220 @kwarg exact: Exact C{Rhumb...} to use (C{bool} or C{Rhumb...}), see
1221 method L{Ellipsoid.rhumb_}.
1222 @kwarg radius: Optional earth radius (C{meter}) or earth model (L{Datum},
1223 L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}), overriding
1224 this point's datum.
1225 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{other}}
1226 point (C{bool}).
1228 @return: Distance (C{meter}, the same units as this point's datum
1229 (ellipsoid) axes or B{C{radius}}.
1231 @raise TypeError: The B{C{other}} point is incompatible or B{C{radius}}
1232 is invalid.
1234 @raise ValueError: Invalid B{C{radius}}.
1235 '''
1236 r, _, Cs = self._rhumb3(exact, radius)
1237 return r._Inverse(self, other, wrap, outmask=Cs.DISTANCE).s12
1239 def rhumbIntersecant2(self, circle, point, other, height=None,
1240 **exact_radius_wrap_eps_tol):
1241 '''Compute the intersections of a circle and a rhumb line given as two
1242 points or as a point and azimuth.
1244 @arg circle: Radius of the circle centered at this location (C{meter}),
1245 or a point on the circle (this C{LatLon}).
1246 @arg point: The start point of the rhumb line (this C{LatLon}).
1247 @arg other: An other point I{on} (this C{LatLon}) or the azimuth I{of}
1248 (compass C{degrees}) the rhumb line.
1249 @kwarg height: Optional height for the intersection points (C{meter},
1250 conventionally) or C{None} for interpolated heights.
1251 @kwarg exact_radius_wrap_eps_tol: Optional keyword arguments, see
1252 methods L{rhumbLine} and L{RhumbLineAux.Intersecant2}
1253 or L{RhumbLine.Intersecant2}.
1255 @return: 2-Tuple of the intersection points (representing a chord),
1256 each an instance of this class. Both points are the same
1257 instance if the rhumb line is tangent to the circle.
1259 @raise IntersectionError: The circle and rhumb line do not intersect.
1261 @raise TypeError: If B{C{point}} is not this C{LatLon} or B{C{circle}}
1262 or B{C{other}} invalid.
1264 @raise ValueError: Invalid B{C{circle}}, B{C{other}}, B{C{height}}
1265 or B{C{exact_radius_wrap}}.
1267 @see: Methods L{RhumbLineAux.Intersecant2} and L{RhumbLine.Intersecant2}.
1268 '''
1269 def _kwds3(eps=EPS, tol=_TOL, wrap=False, **kwds):
1270 return kwds, wrap, dict(eps=eps, tol=tol)
1272 exact_radius, w, eps_tol = _kwds3(**exact_radius_wrap_eps_tol)
1274 p = _unrollon(self, self.others(point=point), wrap=w)
1275 try:
1276 r = Radius_(circle=circle) if _isRadius(circle) else \
1277 self.rhumbDistanceTo(self.others(circle=circle), wrap=w, **exact_radius)
1278 rl = p.rhumbLine(other, wrap=w, **exact_radius)
1279 P, Q = rl.Intersecant2(self.lat, self.lon, r, **eps_tol)
1281 return self._intersecend2(p, other, w, height, rl.rhumb, P, Q,
1282 self.rhumbIntersecant2)
1284 except (TypeError, ValueError) as x:
1285 raise _xError(x, center=self, circle=circle, point=point, other=other,
1286 **exact_radius_wrap_eps_tol)
1288 def rhumbLine(self, other, exact=False, radius=None, wrap=False, **name_caps):
1289 '''Get a rhumb line through this point at a given azimuth or through
1290 this and an other point.
1292 @arg other: The azimuth I{of} (compass C{degrees}) or an other point
1293 I{on} (this C{LatLon}) the rhumb line.
1294 @kwarg exact: Exact C{Rhumb...} to use (C{bool} or C{Rhumb...}), see
1295 method L{Ellipsoid.rhumb_}.
1296 @kwarg radius: Optional earth radius (C{meter}) or earth model
1297 (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}),
1298 overriding this point's datum.
1299 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{other}}
1300 point (C{bool}).
1301 @kwarg name_caps: Optional C{B{name}=str} and C{caps}, see L{RhumbLine}
1302 or L{RhumbLineAux} C{B{caps}}.
1304 @return: A C{RhumbLine} instance.
1306 @raise TypeError: Invalid B{C{radius}} or B{C{other}} not C{scalar} nor
1307 this C{LatLon}.
1309 @see: Modules L{rhumb.aux_} and L{rhumb.ekx}.
1310 '''
1311 r, _, Cs = self._rhumb3(exact, radius)
1312 kwds = _xkwds(name_caps, name=self.name, caps=Cs.LINE_OFF)
1313 rl = r._DirectLine( self, other, **kwds) if _isDegrees(other) else \
1314 r._InverseLine(self, self.others(other), wrap, **kwds)
1315 return rl
1317 def rhumbMidpointTo(self, other, exact=False, radius=None,
1318 height=None, fraction=_0_5, wrap=False):
1319 '''Return the (loxodromic) midpoint on the rhumb line between this and
1320 an other point.
1322 @arg other: The other point (this C{LatLon}).
1323 @kwarg exact: Exact C{Rhumb...} to use (C{bool} or C{Rhumb...}), see
1324 method L{Ellipsoid.rhumb_}.
1325 @kwarg radius: Optional earth radius (C{meter}) or earth model (L{Datum},
1326 L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}), overriding
1327 this point's datum.
1328 @kwarg height: Optional height, overriding the mean height (C{meter}).
1329 @kwarg fraction: Midpoint location from this point (C{scalar}), 0 for this,
1330 1 for the B{C{other}}, 0.5 for halfway between this and
1331 the B{C{other}} point, may be negative or greater than 1.
1332 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{other}}
1333 point (C{bool}).
1335 @return: The midpoint at the given B{C{fraction}} along the rhumb line
1336 (this C{LatLon}).
1338 @raise TypeError: The B{C{other}} point is incompatible or B{C{radius}}
1339 is invalid.
1341 @raise ValueError: Invalid B{C{height}} or B{C{fraction}}.
1342 '''
1343 r, D, _ = self._rhumb3(exact, radius)
1344 f = Scalar(fraction=fraction)
1345 d = r._Inverse(self, self.others(other), wrap) # C.AZIMUTH_DISTANCE
1346 d = r._Direct( self, d.azi12, d.s12 * f)
1347 h = self._havg(other, f=f, h=height)
1348 return self.classof(d.lat2, d.lon2, datum=D, height=h)
1350 @property_RO
1351 def sphericalLatLon(self):
1352 '''Get the C{LatLon type} iff spherical, overloaded in L{LatLonSphericalBase}.
1353 '''
1354 return False
1356 def thomasTo(self, other, wrap=False):
1357 '''Compute the distance between this and an other point using
1358 U{Thomas'<https://apps.DTIC.mil/dtic/tr/fulltext/u2/703541.pdf>}
1359 formula.
1361 @arg other: The other point (C{LatLon}).
1362 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
1363 the B{C{other}} point (C{bool}).
1365 @return: Distance (C{meter}, same units as the axes of
1366 this point's datum ellipsoid).
1368 @raise TypeError: The B{C{other}} point is not C{LatLon}.
1370 @see: Function L{pygeodesy.thomas} and methods L{cosineAndoyerLambertTo},
1371 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
1372 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
1373 L{flatPolarTo}, L{haversineTo} and L{vincentysTo}.
1374 '''
1375 return self._distanceTo_(self._formy.thomas_, other, wrap=wrap)
1377 @deprecated_method
1378 def to2ab(self): # PYCHOK no cover
1379 '''DEPRECATED, use property L{philam}.'''
1380 return self.philam
1382 def toCartesian(self, height=None, Cartesian=None, **Cartesian_kwds):
1383 '''Convert this point to cartesian, I{geocentric} coordinates,
1384 also known as I{Earth-Centered, Earth-Fixed} (ECEF).
1386 @kwarg height: Optional height, overriding this point's height
1387 (C{meter}, conventionally).
1388 @kwarg Cartesian: Optional class to return the geocentric
1389 coordinates (C{Cartesian}) or C{None}.
1390 @kwarg Cartesian_kwds: Optional, additional B{C{Cartesian}}
1391 keyword arguments, ignored if
1392 C{B{Cartesian} is None}.
1394 @return: A B{C{Cartesian}} or if B{C{Cartesian}} is C{None},
1395 an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M,
1396 datum)} with C{C=0} and C{M} if available.
1398 @raise TypeError: Invalid B{C{Cartesian}} or B{C{Cartesian_kwds}}.
1400 @see: Methods C{toNvector}, C{toVector} and C{toVector3d}.
1401 '''
1402 r = self._ecef9 if height is None else self.toEcef(height=height)
1403 if Cartesian is not None: # class or .classof
1404 r = Cartesian(r, **_xkwds(Cartesian_kwds, name=self.name))
1405 _xdatum(r.datum, self.datum)
1406 return r
1408 def _toCartesianEcef(self, height=None, i=None, up=2, **name_point):
1409 '''(INTERNAL) Convert to cartesian and check Ecef's before and after.
1410 '''
1411 p = self.others(up=up, **name_point)
1412 c = p.toCartesian(height=height)
1413 E = self.Ecef
1414 if E:
1415 for p in (p, c):
1416 e = _xattr(p, Ecef=None)
1417 if e not in (None, E): # PYCHOK no cover
1418 n, _ = name_point.popitem()
1419 if i is not None:
1420 n = Fmt.SQUARE(n, i)
1421 raise _ValueError(n, e, txt=_incompatible(E.__name__))
1422 return c
1424 def toDatum(self, datum2, height=None, name=NN):
1425 '''I{Must be overloaded}.'''
1426 notOverloaded(self, datum2, height=height, name=name)
1428 def toEcef(self, height=None, M=False):
1429 '''Convert this point to I{geocentric} coordinates, also known as
1430 I{Earth-Centered, Earth-Fixed} (U{ECEF<https://WikiPedia.org/wiki/ECEF>}).
1432 @kwarg height: Optional height, overriding this point's height
1433 (C{meter}, conventionally).
1434 @kwarg M: Optionally, include the rotation L{EcefMatrix} (C{bool}).
1436 @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
1437 with C{C=0} and C{M} if available.
1439 @raise EcefError: A C{.datum} or an ECEF issue.
1440 '''
1441 return self._ecef9 if height in (None, self.height) else \
1442 self._Ecef_forward(self.lat, self.lon, height=height, M=M)
1444 @deprecated_method
1445 def to3llh(self, height=None): # PYCHOK no cover
1446 '''DEPRECATED, use property L{latlonheight} or C{latlon.to3Tuple(B{height})}.'''
1447 return self.latlonheight if height in (None, self.height) else \
1448 self.latlon.to3Tuple(height)
1450 def toLocal(self, Xyz=None, ltp=None, **Xyz_kwds):
1451 '''Convert this I{geodetic} point to I{local} C{X}, C{Y} and C{Z}.
1453 @kwarg Xyz: Optional class to return C{X}, C{Y} and C{Z}
1454 (L{XyzLocal}, L{Enu}, L{Ned}) or C{None}.
1455 @kwarg ltp: The I{local tangent plane} (LTP) to use,
1456 overriding this point's LTP (L{Ltp}).
1457 @kwarg Xyz_kwds: Optional, additional B{C{Xyz}} keyword
1458 arguments, ignored if C{B{Xyz} is None}.
1460 @return: An B{C{Xyz}} instance or if C{B{Xyz} is None},
1461 a L{Local9Tuple}C{(x, y, z, lat, lon, height,
1462 ltp, ecef, M)} with C{M=None}, always.
1464 @raise TypeError: Invalid B{C{ltp}}.
1465 '''
1466 p = self._ltp._xLtp(ltp, self._Ltp)
1467 return p._ecef2local(self._ecef9, Xyz, Xyz_kwds)
1469 def toLtp(self, Ecef=None):
1470 '''Return the I{local tangent plane} (LTP) for this point.
1472 @kwarg Ecef: Optional ECEF I{class} (L{EcefKarney}, ...
1473 L{EcefYou}), overriding this point's C{Ecef}.
1474 '''
1475 return self._Ltp if Ecef in (None, self.Ecef) else self._ltp.Ltp(
1476 self, ecef=Ecef(self.datum), name=self.name)
1478 def toNormal(self, deep=False, name=NN):
1479 '''Get this point I{normalized} to C{abs(lat) <= 90}
1480 and C{abs(lon) <= 180}.
1482 @kwarg deep: If C{True} make a deep, otherwise a
1483 shallow copy (C{bool}).
1484 @kwarg name: Optional name of the copy (C{str}).
1486 @return: A copy of this point, I{normalized} and
1487 optionally renamed (C{LatLon}).
1489 @see: Property L{isnormal}, method L{normal} and function
1490 L{pygeodesy.normal}.
1491 '''
1492 ll = self.copy(deep=deep)
1493 _ = ll.normal()
1494 if name:
1495 ll.rename(name)
1496 return ll
1498 def toNvector(self, h=None, Nvector=None, **Nvector_kwds):
1499 '''Convert this point to C{n-vector} (normal to the earth's surface)
1500 components, I{including height}.
1502 @kwarg h: Optional height, overriding this point's height (C{meter}).
1503 @kwarg Nvector: Optional class to return the C{n-vector} components
1504 (C{Nvector}) or C{None}.
1505 @kwarg Nvector_kwds: Optional, additional B{C{Nvector}} keyword
1506 arguments, ignored if C{B{Nvector} is None}.
1508 @return: An B{C{Nvector}} or a L{Vector4Tuple}C{(x, y, z, h)} if
1509 B{C{Nvector}} is C{None}.
1511 @raise TypeError: Invalid B{C{h}}, B{C{Nvector}} or B{C{Nvector_kwds}}
1512 item.
1514 @see: Methods C{toCartesian}, C{toVector} and C{toVector3d}.
1515 '''
1516 h = self._heigHt(h)
1517 if Nvector is None:
1518 r = self._n_xyz3.to4Tuple(h)
1519 else:
1520 x, y, z = self._n_xyz3
1521 r = Nvector(x, y, z, h=h, ll=self, **_xkwds(Nvector_kwds, name=self.name))
1522 return r
1524 def toStr(self, form=F_DMS, joined=_COMMASPACE_, m=_m_, **prec_sep_s_D_M_S): # PYCHOK expected
1525 '''Convert this point to a "lat, lon[, +/-height]" string, formatted
1526 in the given C{B{form}at}.
1528 @kwarg form: The lat-/longitude C{B{form}at} to use (C{str}), see
1529 functions L{pygeodesy.latDMS} or L{pygeodesy.lonDMS}.
1530 @kwarg joined: Separator to join the lat-, longitude and heigth
1531 strings (C{str} or C{None} or C{NN} for non-joined).
1532 @kwarg m: Optional unit of the height (C{str}), use C{None} to
1533 exclude height from the returned string.
1534 @kwarg prec_sep_s_D_M_S: Optional C{B{prec}ision}, C{B{sep}arator},
1535 B{C{s_D}}, B{C{s_M}}, B{C{s_S}} and B{C{s_DMS}} keyword
1536 arguments, see function L{pygeodesy.latDMS} or
1537 L{pygeodesy.lonDMS}.
1539 @return: This point in the specified C{B{form}at}, etc. (C{str} or
1540 a 2- or 3-tuple C{(lat_str, lon_str[, height_str])} if
1541 C{B{joined}=NN} or C{B{joined}=None}).
1543 @see: Function L{pygeodesy.latDMS} or L{pygeodesy.lonDMS} for more
1544 details about keyword arguments C{B{form}at}, C{B{prec}ision},
1545 C{B{sep}arator}, B{C{s_D}}, B{C{s_M}}, B{C{s_S}} and B{C{s_DMS}}.
1546 '''
1547 t = (latDMS(self.lat, form=form, **prec_sep_s_D_M_S),
1548 lonDMS(self.lon, form=form, **prec_sep_s_D_M_S))
1549 if self.height and m is not None:
1550 t += (self.heightStr(m=m),)
1551 return joined.join(t) if joined else t
1553 def toVector(self, Vector=None, **Vector_kwds):
1554 '''Convert this point to a C{Vector} with the I{geocentric} C{(x,
1555 y, z)} (ECEF) coordinates, I{ignoring height}.
1557 @kwarg Vector: Optional class to return the I{geocentric}
1558 components (L{Vector3d}) or C{None}.
1559 @kwarg Vector_kwds: Optional, additional B{C{Vector}} keyword
1560 arguments, ignored if C{B{Vector} is None}.
1562 @return: A B{C{Vector}} or a L{Vector3Tuple}C{(x, y, z)}
1563 if B{C{Vector}} is C{None}.
1565 @raise TypeError: Invalid B{C{Vector}} or B{C{Vector_kwds}} item.
1567 @see: Methods C{toCartesian}, C{toNvector} and C{toVector3d}.
1568 '''
1569 return self._ecef9.toVector(Vector=Vector, **Vector_kwds)
1571 def toVector3d(self, norm=True, **Vector3d_kwds):
1572 '''Convert this point to a L{Vector3d} with the I{geocentric} C{(x,
1573 y, z)} (ECEF) I{unit} coordinates, I{ignoring height}.
1575 @kwarg norm: Normalize the 3-D vector (C{bool}).
1576 @kwarg Vector3d_kwds: Optional L{Vector3d} keyword arguments.
1578 @return: Unit vector (L{Vector3d}).
1580 @raise TypeError: Invalid B{C{Vector3d_kwds}} item.
1582 @see: Methods C{toCartesian}, C{toNvector} and C{toVector}.
1583 '''
1584 r = self.toVector(Vector=Vector3d, **Vector3d_kwds)
1585 if norm:
1586 r = r.unit(ll=self)
1587 return r
1589 def toWm(self, **toWm_kwds):
1590 '''Convert this point to a WM coordinate.
1592 @kwarg toWm_kwds: Optional L{pygeodesy.toWm} keyword arguments.
1594 @return: The WM coordinate (L{Wm}).
1596 @see: Function L{pygeodesy.toWm}.
1597 '''
1598 return self._wm if not toWm_kwds else _MODS.webmercator.toWm(
1599 self, **_xkwds(toWm_kwds, name=self.name))
1601 @deprecated_method
1602 def to3xyz(self): # PYCHOK no cover
1603 '''DEPRECATED, use property L{xyz} or method L{toNvector}, L{toVector},
1604 L{toVector3d} or perhaps (geocentric) L{toEcef}.'''
1605 return self.xyz # self.toVector()
1607 def vincentysTo(self, other, **radius_wrap):
1608 '''Compute the distance between this and an other point using
1609 U{Vincenty's<https://WikiPedia.org/wiki/Great-circle_distance>}
1610 spherical formula.
1612 @arg other: The other point (C{LatLon}).
1613 @kwarg radius_wrap: Optional keyword arguments for function
1614 L{pygeodesy.vincentys}, overriding the
1615 default mean C{radius} of this point's
1616 datum ellipsoid.
1618 @return: Distance (C{meter}, same units as B{C{radius}}).
1620 @raise TypeError: The B{C{other}} point is not C{LatLon}.
1622 @see: Function L{pygeodesy.vincentys} and methods L{cosineAndoyerLambertTo},
1623 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
1624 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
1625 L{flatPolarTo}, L{haversineTo} and L{thomasTo}.
1626 '''
1627 return self._distanceTo(self._formy.vincentys, other, **_xkwds(radius_wrap, radius=None))
1629 @Property_RO
1630 def _wm(self):
1631 '''(INTERNAL) Get this point as webmercator (L{Wm}).
1632 '''
1633 return _MODS.webmercator.toWm(self)
1635 @property_RO
1636 def xyz(self):
1637 '''Get the I{geocentric} C{(x, y, z)} coordinates (L{Vector3Tuple}C{(x, y, z)})
1638 '''
1639 return self._ecef9.xyz
1641 @Property_RO
1642 def xyzh(self):
1643 '''Get the I{geocentric} C{(x, y, z)} coordinates and height (L{Vector4Tuple}C{(x, y, z, h)})
1644 '''
1645 return self.xyz.to4Tuple(self.height)
1648class _toCartesian3(object): # see also .formy._idllmn6, .geodesicw._wargs, .vector2d._numpy
1649 '''(INTERNAL) Wrapper to convert 2 other points.
1650 '''
1651 @contextmanager # <https://www.Python.org/dev/peps/pep-0343/> Examples
1652 def __call__(self, p, p2, p3, wrap, **kwds):
1653 try:
1654 if wrap:
1655 p2, p3 = map1(_Wrap.point, p2, p3)
1656 kwds = _xkwds(kwds, wrap=wrap)
1657 yield (p. toCartesian().copy(name=_point_), # copy to rename
1658 p._toCartesianEcef(up=4, point2=p2),
1659 p._toCartesianEcef(up=4, point3=p3))
1660 except (AssertionError, TypeError, ValueError) as x: # Exception?
1661 raise _xError(x, point=p, point2=p2, point3=p3, **kwds)
1663_toCartesian3 = _toCartesian3() # PYCHOK singleton
1666def _latlonheight3(latlonh, height, wrap): # in .points.LatLon_.__init__
1667 '''(INTERNAL) Get 3-tuple C{(lat, lon, height)}.
1668 '''
1669 try:
1670 lat, lon = latlonh.lat, latlonh.lon
1671 height = _xattr(latlonh, height=height)
1672 except AttributeError:
1673 raise _IsnotError(_LatLon_, latlonh=latlonh)
1674 if wrap:
1675 lat, lon = _Wrap.latlon(lat, lon)
1676 return lat, lon, height
1679def _trilaterate5(p1, d1, p2, d2, p3, d3, area=True, eps=EPS1, # MCCABE 13
1680 radius=R_M, wrap=False):
1681 '''(INTERNAL) Trilaterate three points by I{area overlap} or by
1682 I{perimeter intersection} of three circles.
1684 @note: The B{C{radius}} is only needed for both the n-vectorial
1685 and C{sphericalTrigonometry.LatLon.distanceTo} methods and
1686 silently ignored by the C{ellipsoidalExact}, C{-GeodSolve},
1687 C{-Karney} and C{-Vincenty.LatLon.distanceTo} methods.
1688 '''
1689 p2, p3, w = _unrollon3(p1, p2, p3, wrap)
1691 r1 = Distance_(distance1=d1)
1692 r2 = Distance_(distance2=d2)
1693 r3 = Distance_(distance3=d3)
1694 m = 0 if area else (r1 + r2 + r3)
1695 pc = 0
1696 t = []
1697 for _ in range(3):
1698 try: # intersection of circle (p1, r1) and (p2, r2)
1699 c1, c2 = p1.intersections2(r1, p2, r2, wrap=w)
1701 if area: # check overlap
1702 if c1 is c2: # abutting
1703 c = c1
1704 else: # nearest point on radical
1705 c = p3.nearestOn(c1, c2, within=True, wrap=w)
1706 d = r3 - p3.distanceTo(c, radius=radius, wrap=w)
1707 if d > eps: # sufficient overlap
1708 t.append((d, c))
1709 m = max(m, d)
1711 else: # check intersection
1712 for c in ((c1,) if c1 is c2 else (c1, c2)):
1713 d = fabs(r3 - p3.distanceTo(c, radius=radius, wrap=w))
1714 if d < eps: # below margin
1715 t.append((d, c))
1716 m = min(m, d)
1718 except IntersectionError as x:
1719 if _concentric_ in str(x): # XXX ConcentricError?
1720 pc += 1
1722 p1, r1, p2, r2, p3, r3 = p2, r2, p3, r3, p1, r1 # rotate
1724 if t: # get min, max, points and count ...
1725 t = tuple(sorted(t))
1726 n = len(t), # as 1-tuple
1727 # ... or for a single trilaterated result,
1728 # min *is* max, min- *is* maxPoint and n=1, 2 or 3
1729 return Trilaterate5Tuple(t[0] + t[-1] + n) # *(t[0] + ...)
1731 elif area and pc == 3: # all pairwise concentric ...
1732 r, p = min((r1, p1), (r2, p2), (r3, p3))
1733 m = max(r1, r2, r3)
1734 # ... return "smallest" point twice, the smallest
1735 # and largest distance and n=0 for concentric
1736 return Trilaterate5Tuple(float(r), p, float(m), p, 0)
1738 n, f = (_overlap_, max) if area else (_intersection_, min)
1739 t = _COMMASPACE_(_no_(n), '%s %.3g' % (f.__name__, m))
1740 raise IntersectionError(area=area, eps=eps, wrap=wrap, txt=t)
1743__all__ += _ALL_DOCS(LatLonBase)
1745# **) MIT License
1746#
1747# Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.
1748#
1749# Permission is hereby granted, free of charge, to any person obtaining a
1750# copy of this software and associated documentation files (the "Software"),
1751# to deal in the Software without restriction, including without limitation
1752# the rights to use, copy, modify, merge, publish, distribute, sublicense,
1753# and/or sell copies of the Software, and to permit persons to whom the
1754# Software is furnished to do so, subject to the following conditions:
1755#
1756# The above copyright notice and this permission notice shall be included
1757# in all copies or substantial portions of the Software.
1758#
1759# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
1760# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1761# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
1762# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
1763# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
1764# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
1765# OTHER DEALINGS IN THE SOFTWARE.