Coverage for pygeodesy/latlonBase.py: 93%
433 statements
« prev ^ index » next coverage.py v7.2.2, created at 2023-07-12 13:40 -0400
« prev ^ index » next coverage.py v7.2.2, created at 2023-07-12 13:40 -0400
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>}, U{-ellipsoidal<https://www.Movable-Type.co.UK/scripts/geodesy/docs/latlon-ellipsoidal.js.html>} and U{-vectors
7<https://www.Movable-Type.co.UK/scripts/latlong-vectors.html>} and I{Charles Karney}'s
8U{Rhumb<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1Rhumb.html>}
9and U{RhumbLine<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1RhumbLine.html>} classes.
10'''
12from pygeodesy.basics import isscalar, isstr, map1, _xinstanceof
13from pygeodesy.constants import EPS, EPS0, EPS1, EPS4, INT0, R_M, \
14 _0_0, _0_5, _1_0
15# from pygeodesy.datums import _spherical_datum # from .formy
16from pygeodesy.dms import F_D, F_DMS, latDMS, lonDMS, parse3llh
17# from pygeodesy.ecef import EcefKarney # _MODS
18from pygeodesy.errors import _incompatible, IntersectionError, _IsnotError, \
19 _TypeError, _ValueError, _xdatum, _xError, \
20 _xkwds, _xkwds_not
21# from pygeodesy.fmath import favg # _MODS
22from pygeodesy.formy import antipode, compassAngle, cosineAndoyerLambert_, \
23 cosineForsytheAndoyerLambert_, cosineLaw, \
24 equirectangular, euclidean, flatLocal_, \
25 flatPolar, hartzell, haversine, isantipode, \
26 _isequalTo, isnormal, normal, philam2n_xyz, \
27 thomas_, vincentys, _spherical_datum
28from pygeodesy.interns import NN, _COMMASPACE_, _concentric_, _height_, \
29 _intersection_, _m_, _LatLon_, _no_, \
30 _overlap_, _point_ # PYCHOK used!
31# from pygeodesy.iters import PointsIter, points2 # from .vector3d, _MODS
32from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
33# from pygeodesy.ltp import Ltp, _xLtp # _MODS
34from pygeodesy.named import _NamedBase, notOverloaded, Fmt
35from pygeodesy.namedTuples import Bounds2Tuple, LatLon2Tuple, PhiLam2Tuple, \
36 Trilaterate5Tuple, Vector3Tuple
37# from pygeodesy.nvectorBase import _N_vector_ # _MODS
38from pygeodesy.props import deprecated_method, Property, Property_RO, \
39 property_RO, _update_all
40# from pygeodesy.rhumbx import Caps, Rhumb # _MODS
41# from pygeodesy.streprs import Fmt, hstr # from .named, _MODS
42from pygeodesy.units import Distance_, Lat, Lon, Height, Radius, Radius_, \
43 Scalar, Scalar_
44from pygeodesy.utily import _unrollon, _unrollon3, _Wrap
45from pygeodesy.vector2d import _circin6, Circin6Tuple, _circum3, circum4_, \
46 Circum3Tuple, _radii11ABC
47from pygeodesy.vector3d import nearestOn6, Vector3d, PointsIter
49from contextlib import contextmanager
50from math import asin, cos, degrees, fabs, radians
52__all__ = _ALL_LAZY.latlonBase
53__version__ = '23.06.12'
56class LatLonBase(_NamedBase):
57 '''(INTERNAL) Base class for C{LatLon} points on spherical or
58 ellipsoidal earth models.
59 '''
60 _clipid = INT0 # polygonal clip, see .booleans
61 _datum = None # L{Datum}, to be overriden
62 _height = INT0 # height (C{meter}), default
63 _lat = 0 # latitude (C{degrees})
64 _lon = 0 # longitude (C{degrees})
66 def __init__(self, latlonh, lon=None, height=0, wrap=False, name=NN):
67 '''New C{LatLon}.
69 @arg latlonh: Latitude (C{degrees} or DMS C{str} with N or S suffix) or
70 a previous C{LatLon} instance provided C{B{lon}=None}.
71 @kwarg lon: Longitude (C{degrees} or DMS C{str} with E or W suffix) or
72 C(None), indicating B{C{latlonh}} is a C{LatLon}.
73 @kwarg height: Optional height above (or below) the earth surface
74 (C{meter}, conventionally).
75 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}}
76 (C{bool}).
77 @kwarg name: Optional name (C{str}).
79 @return: New instance (C{LatLon}).
81 @raise RangeError: A B{C{lon}} or C{lat} value outside the valid
82 range and L{rangerrors} set to C{True}.
84 @raise TypeError: If B{C{latlonh}} is not a C{LatLon}.
86 @raise UnitError: Invalid B{C{lat}}, B{C{lon}} or B{C{height}}.
88 @example:
90 >>> p = LatLon(50.06632, -5.71475)
91 >>> q = LatLon('50°03′59″N', """005°42'53"W""")
92 >>> r = LatLon(p)
93 '''
94 if name:
95 self.name = name
97 if lon is None:
98 try:
99 lat, lon = latlonh.lat, latlonh.lon
100 height = latlonh.get(_height_, height)
101 except AttributeError:
102 raise _IsnotError(_LatLon_, latlonh=latlonh)
103 if wrap:
104 lat, lon = _Wrap.latlon(lat, lon)
105 elif wrap:
106 lat, lon = _Wrap.latlonDMS2(latlonh, lon)
107 else:
108 lat = latlonh
110 self._lat = Lat(lat) # parseDMS2(lat, lon)
111 self._lon = Lon(lon) # PYCHOK LatLon2Tuple
112 if height: # elevation
113 self._height = Height(height)
115 def __eq__(self, other):
116 return self.isequalTo(other)
118 def __ne__(self, other):
119 return not self.isequalTo(other)
121 def __str__(self):
122 return self.toStr(form=F_D, prec=6)
124 def antipode(self, height=None):
125 '''Return the antipode, the point diametrically opposite
126 to this point.
128 @kwarg height: Optional height of the antipode (C{meter}),
129 this point's height otherwise.
131 @return: The antipodal point (C{LatLon}).
132 '''
133 h = self._heigHt(height)
134 return self.classof(*antipode(*self.latlon), height=h)
136 @deprecated_method
137 def bounds(self, wide, tall, radius=R_M): # PYCHOK no cover
138 '''DEPRECATED, use method C{boundsOf}.'''
139 return self.boundsOf(wide, tall, radius=radius)
141 def boundsOf(self, wide, tall, radius=R_M, height=None):
142 '''Return the SW and NE lat-/longitude of a great circle
143 bounding box centered at this location.
145 @arg wide: Longitudinal box width (C{meter}, same units as
146 B{C{radius}} or C{degrees} if B{C{radius}} is C{None}).
147 @arg tall: Latitudinal box size (C{meter}, same units as
148 B{C{radius}} or C{degrees} if B{C{radius}} is C{None}).
149 @kwarg radius: Mean earth radius (C{meter}) or C{None} if I{both}
150 B{C{wide}} and B{C{tall}} are in C{degrees}.
151 @kwarg height: Height for C{latlonSW} and C{latlonNE} (C{meter}),
152 overriding the point's height.
154 @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)}, the
155 lower-left and upper-right corner (C{LatLon}).
157 @see: U{https://www.Movable-Type.co.UK/scripts/latlong-db.html}
158 '''
159 w = Scalar_(wide=wide) * _0_5
160 t = Scalar_(tall=tall) * _0_5
161 if radius is not None:
162 r = Radius_(radius)
163 c = cos(self.phi)
164 w = degrees(asin(w / r) / c) if fabs(c) > EPS0 else _0_0 # XXX
165 t = degrees(t / r)
166 y, t = self.lat, fabs(t)
167 x, w = self.lon, fabs(w)
169 h = self._heigHt(height)
170 sw = self.classof(y - t, x - w, height=h)
171 ne = self.classof(y + t, x + w, height=h)
172 return Bounds2Tuple(sw, ne, name=self.name)
174 def chordTo(self, other, height=None, wrap=False):
175 '''Compute the length of the chord through the earth between
176 this and an other point.
178 @arg other: The other point (C{LatLon}).
179 @kwarg height: Overriding height for both points (C{meter})
180 or C{None} for each point's height.
181 @kwarg wrap: If C{True}, wrap or I{normalize} the B{C{other}}
182 point (C{bool}).
184 @return: The chord length (conventionally C{meter}).
186 @raise TypeError: The B{C{other}} point is not C{LatLon}.
187 '''
188 def _v3d(ll):
189 t = ll.toEcef(height=height) # .toVector(Vector=Vector3d)
190 return Vector3d(t.x, t.y, t.z)
192 p = self.others(other)
193 if wrap:
194 p = _Wrap.point(p)
195 return _v3d(self).minus(_v3d(p)).length
197 def circin6(self, point2, point3, eps=EPS4, wrap=False):
198 '''Return the radius and center of the I{inscribed} aka I{In-}circle
199 of the (planar) triangle formed by this and two other points.
201 @arg point2: Second point (C{LatLon}).
202 @arg point3: Third point (C{LatLon}).
203 @kwarg eps: Tolerance for function L{pygeodesy.trilaterate3d2}.
204 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{point2}} and
205 B{C{point3}} (C{bool}).
207 @return: L{Circin6Tuple}C{(radius, center, deltas, cA, cB, cC)}. The
208 C{center} and contact points C{cA}, C{cB} and C{cC}, each an
209 instance of this (sub-)class, are co-planar with this and the
210 two given points, see the B{Note} below.
212 @raise ImportError: Package C{numpy} not found, not installed or older
213 than version 1.10.
215 @raise IntersectionError: Near-coincident or -colinear points or
216 a trilateration or C{numpy} issue.
218 @raise TypeError: Invalid B{C{point2}} or B{C{point3}}.
220 @note: The C{center} is trilaterated in cartesian (ECEF) space and converted
221 back to geodetic lat-, longitude and height. The latter, conventionally
222 in C{meter} indicates whether the C{center} is above, below or on the
223 surface of the earth model. If C{deltas} is C{None}, the C{center} is
224 I{un}ambigous. Otherwise C{deltas} is a L{LatLon3Tuple}C{(lat, lon,
225 height)} representing the differences between both results from
226 L{pygeodesy.trilaterate3d2} and C{center} is the mean thereof.
228 @see: Function L{pygeodesy.circin6}, method L{circum3}, U{Incircle
229 <https://MathWorld.Wolfram.com/Incircle.html>} and U{Contact Triangle
230 <https://MathWorld.Wolfram.com/ContactTriangle.html>}.
231 '''
232 with _toCartesian3(self, point2, point3, wrap) as cs:
233 r, c, d, cA, cB, cC = _circin6(*cs, eps=eps, useZ=True, dLL3=True,
234 datum=self.datum) # PYCHOK unpack
235 return Circin6Tuple(r, c.toLatLon(), d, cA.toLatLon(), cB.toLatLon(), cC.toLatLon())
237 def circum3(self, point2, point3, circum=True, eps=EPS4, wrap=False):
238 '''Return the radius and center of the smallest circle I{through} or I{containing}
239 this and two other points.
241 @arg point2: Second point (C{LatLon}).
242 @arg point3: Third point (C{LatLon}).
243 @kwarg circum: If C{True} return the C{circumradius} and C{circumcenter},
244 always, ignoring the I{Meeus}' Type I case (C{bool}).
245 @kwarg eps: Tolerance for function L{pygeodesy.trilaterate3d2}.
246 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{point2}} and
247 B{C{point3}} (C{bool}).
249 @return: A L{Circum3Tuple}C{(radius, center, deltas)}. The C{center}, an
250 instance of this (sub-)class, is co-planar with this and the two
251 given points. If C{deltas} is C{None}, the C{center} is
252 I{un}ambigous. Otherwise C{deltas} is a L{LatLon3Tuple}C{(lat,
253 lon, height)} representing the difference between both results
254 from L{pygeodesy.trilaterate3d2} and C{center} is the mean thereof.
256 @raise ImportError: Package C{numpy} not found, not installed or older than
257 version 1.10.
259 @raise IntersectionError: Near-concentric, -coincident or -colinear points,
260 incompatible C{Ecef} classes or a trilateration
261 or C{numpy} issue.
263 @raise TypeError: Invalid B{C{point2}} or B{C{point3}}.
265 @note: The C{center} is trilaterated in cartesian (ECEF) space and converted
266 back to geodetic lat-, longitude and height. The latter, conventionally
267 in C{meter} indicates whether the C{center} is above, below or on the
268 surface of the earth model. If C{deltas} is C{None}, the C{center} is
269 I{un}ambigous. Otherwise C{deltas} is a L{LatLon3Tuple}C{(lat, lon,
270 height)} representing the difference between both results from
271 L{pygeodesy.trilaterate3d2} and C{center} is the mean thereof.
273 @see: Function L{pygeodesy.circum3} and methods L{circin6} and L{circum4_}.
274 '''
275 with _toCartesian3(self, point2, point3, wrap, circum=circum) as cs:
276 r, c, d = _circum3(*cs, circum=circum, eps=eps, useZ=True, dLL3=True, # XXX -3d2
277 clas=cs[0].classof, datum=self.datum) # PYCHOK unpack
278 return Circum3Tuple(r, c.toLatLon(), d)
280 def circum4_(self, *points, **wrap):
281 '''Best-fit a sphere through this and two or more other points.
283 @arg points: The other points (each a C{LatLon}).
284 @kwarg wrap: If C{True}, wrap or I{normalize} the B{C{points}}
285 (C{bool}), default C{False}.
287 @return: L{Circum4Tuple}C{(radius, center, rank, residuals)} with C{center}
288 an instance of this (sub-)class.
290 @raise ImportError: Package C{numpy} not found, not installed or older than
291 version 1.10.
293 @raise NumPyError: Some C{numpy} issue.
295 @raise TypeError: One of the B{C{points}} invalid.
297 @raise ValueError: Too few B{C{points}}.
299 @see: Function L{pygeodesy.circum4_} and L{circum3}.
300 '''
301 def _cs(ps, C, wrap=False):
302 _wp = _Wrap.point if wrap else (lambda p: p)
303 for i, p in enumerate(ps):
304 yield C(i=i, points=_wp(p))
306 C = self._toCartesianEcef
307 c = C(point=self)
308 t = circum4_(c, Vector=c.classof, *_cs(points, C, **wrap))
309 c = t.center.toLatLon(LatLon=self.classof)
310 return t.dup(center=c)
312 @property
313 def clipid(self):
314 '''Get the (polygonal) clip (C{int}).
315 '''
316 return self._clipid
318 @clipid.setter # PYCHOK setter!
319 def clipid(self, clipid):
320 '''Get the (polygonal) clip (C{int}).
321 '''
322 self._clipid = int(clipid)
324 @deprecated_method
325 def compassAngle(self, other, **adjust_wrap): # PYCHOK no cover
326 '''DEPRECATED, use method L{compassAngleTo}.'''
327 return self.compassAngleTo(other, **adjust_wrap)
329 def compassAngleTo(self, other, **adjust_wrap):
330 '''Return the angle from North for the direction vector between
331 this and an other point.
333 Suitable only for short, non-near-polar vectors up to a few
334 hundred Km or Miles. Use method C{initialBearingTo} for
335 larger distances.
337 @arg other: The other point (C{LatLon}).
338 @kwarg adjust_wrap: Optional keyword arguments for function
339 L{pygeodesy.compassAngle}.
341 @return: Compass angle from North (C{degrees360}).
343 @raise TypeError: The B{C{other}} point is not C{LatLon}.
345 @note: Courtesy of Martin Schultz.
347 @see: U{Local, flat earth approximation
348 <https://www.EdWilliams.org/avform.htm#flat>}.
349 '''
350 p = self.others(other)
351 return compassAngle(self.lat, self.lon, p.lat, p.lon, **adjust_wrap)
353 def cosineAndoyerLambertTo(self, other, wrap=False):
354 '''Compute the distance between this and an other point using the U{Andoyer-Lambert correction<https://
355 navlib.net/wp-content/uploads/2013/10/admiralty-manual-of-navigation-vol-1-1964-english501c.pdf>}
356 of the U{Law of Cosines<https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>} formula.
358 @arg other: The other point (C{LatLon}).
359 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
360 the B{C{other}} point (C{bool}).
362 @return: Distance (C{meter}, same units as the axes of this
363 point's datum ellipsoid).
365 @raise TypeError: The B{C{other}} point is not C{LatLon}.
367 @see: Function L{pygeodesy.cosineAndoyerLambert} and methods
368 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo},
369 C{distanceTo*}, L{equirectangularTo}, L{euclideanTo},
370 L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo}, L{haversineTo},
371 L{thomasTo} and L{vincentysTo}.
372 '''
373 return self._distanceTo_(cosineAndoyerLambert_, other, wrap=wrap)
375 def cosineForsytheAndoyerLambertTo(self, other, wrap=False):
376 '''Compute the distance between this and an other point using
377 the U{Forsythe-Andoyer-Lambert correction
378 <https://www2.UNB.Ca/gge/Pubs/TR77.pdf>} of the U{Law of Cosines
379 <https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>}
380 formula.
382 @arg other: The other point (C{LatLon}).
383 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
384 the B{C{other}} point (C{bool}).
386 @return: Distance (C{meter}, same units as the axes of
387 this point's datum ellipsoid).
389 @raise TypeError: The B{C{other}} point is not C{LatLon}.
391 @see: Function L{pygeodesy.cosineForsytheAndoyerLambert} and methods
392 L{cosineAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
393 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
394 L{flatPolarTo}, L{haversineTo}, L{thomasTo} and L{vincentysTo}.
395 '''
396 return self._distanceTo_(cosineForsytheAndoyerLambert_, other, wrap=wrap)
398 def cosineLawTo(self, other, radius=None, wrap=False):
399 '''Compute the distance between this and an other point using the
400 U{spherical Law of Cosines
401 <https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>}
402 formula.
404 @arg other: The other point (C{LatLon}).
405 @kwarg radius: Mean earth radius (C{meter}) or C{None}
406 for the mean radius of this point's datum
407 ellipsoid.
408 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
409 the B{C{other}} point (C{bool}).
411 @return: Distance (C{meter}, same units as B{C{radius}}).
413 @raise TypeError: The B{C{other}} point is not C{LatLon}.
415 @see: Function L{pygeodesy.cosineLaw} and methods L{cosineAndoyerLambertTo},
416 L{cosineForsytheAndoyerLambertTo}, C{distanceTo*}, L{equirectangularTo},
417 L{euclideanTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},
418 L{haversineTo}, L{thomasTo} and L{vincentysTo}.
419 '''
420 return self._distanceTo(cosineLaw, other, radius, wrap=wrap)
422 @property_RO
423 def datum(self): # PYCHOK no cover
424 '''(INTERNAL) I{Must be overloaded}, see function C{notOverloaded}.
425 '''
426 notOverloaded(self)
428 def destinationXyz(self, delta, LatLon=None, **LatLon_kwds):
429 '''Calculate the destination using a I{local} delta from this point.
431 @arg delta: Local delta to the destination (L{XyzLocal}, L{Enu},
432 L{Ned} or L{Local9Tuple}).
433 @kwarg LatLon: Optional (geodetic) class to return the destination
434 or C{None}.
435 @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
436 arguments, ignored if C{B{LatLon} is None}.
438 @return: Destination as a C{B{LatLon}(lat, lon, **B{LatLon_kwds})}
439 instance or if C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat,
440 lon, height)} respectively L{LatLon4Tuple}C{(lat, lon,
441 height, datum)} depending on whether a C{datum} keyword
442 is un-/specified.
444 @raise TypeError: Invalid B{C{delta}}, B{C{LatLon}} or B{C{LatLon_kwds}}.
445 '''
446 t = self._ltp._local2ecef(delta, nine=True)
447 return t.toLatLon(LatLon=LatLon, **_xkwds(LatLon_kwds, name=self.name))
449 def _distanceTo(self, func, other, radius=None, **kwds):
450 '''(INTERNAL) Helper for distance methods C{<func>To}.
451 '''
452 p, r = self.others(other, up=2), radius
453 if r is None:
454 r = self._datum.ellipsoid.R1 if self._datum else R_M
455 return func(self.lat, self.lon, p.lat, p.lon, radius=r, **kwds)
457 def _distanceTo_(self, func_, other, wrap=False, radius=None):
458 '''(INTERNAL) Helper for (ellipsoidal) methods C{<func>To}.
459 '''
460 p = self.others(other, up=2)
461 D = self.datum
462 lam21, phi2, _ = _Wrap.philam3(self.lam, p.phi, p.lam, wrap)
463 r = func_(phi2, self.phi, lam21, datum=D)
464 return r * (D.ellipsoid.a if radius is None else radius)
466 @Property_RO
467 def Ecef(self):
468 '''Get the ECEF I{class} (L{EcefKarney}), I{lazily}.
469 '''
470 return _MODS.ecef.EcefKarney # default
472 @Property_RO
473 def _Ecef_forward(self):
474 '''(INTERNAL) Helper for L{_ecef9} and L{toEcef} (C{callable}).
475 '''
476 return self.Ecef(self.datum, name=self.name).forward
478 @Property_RO
479 def _ecef9(self):
480 '''(INTERNAL) Helper for L{toCartesian}, L{toEcef} and L{toCartesian} (L{Ecef9Tuple}).
481 '''
482 return self._Ecef_forward(self, M=True)
484 @deprecated_method
485 def equals(self, other, eps=None): # PYCHOK no cover
486 '''DEPRECATED, use method L{isequalTo}.'''
487 return self.isequalTo(other, eps=eps)
489 @deprecated_method
490 def equals3(self, other, eps=None): # PYCHOK no cover
491 '''DEPRECATED, use method L{isequalTo3}.'''
492 return self.isequalTo3(other, eps=eps)
494 def equirectangularTo(self, other, **radius_adjust_limit_wrap):
495 '''Compute the distance between this and an other point
496 using the U{Equirectangular Approximation / Projection
497 <https://www.Movable-Type.co.UK/scripts/latlong.html#equirectangular>}.
499 Suitable only for short, non-near-polar distances up to a
500 few hundred Km or Miles. Use method L{haversineTo} or
501 C{distanceTo*} for more accurate and/or larger distances.
503 @arg other: The other point (C{LatLon}).
504 @kwarg radius_adjust_limit_wrap: Optional keyword arguments
505 for function L{pygeodesy.equirectangular},
506 overriding the default mean C{radius} of this
507 point's datum ellipsoid.
509 @return: Distance (C{meter}, same units as B{C{radius}}).
511 @raise TypeError: The B{C{other}} point is not C{LatLon}.
513 @see: Function L{pygeodesy.equirectangular} and methods L{cosineAndoyerLambertTo},
514 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
515 C{euclideanTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},
516 L{haversineTo}, L{thomasTo} and L{vincentysTo}.
517 '''
518 return self._distanceTo(equirectangular, other, **radius_adjust_limit_wrap)
520 def euclideanTo(self, other, **radius_adjust_wrap):
521 '''Approximate the C{Euclidian} distance between this and
522 an other point.
524 See function L{pygeodesy.euclidean} for the available B{C{options}}.
526 @arg other: The other point (C{LatLon}).
527 @kwarg radius_adjust_wrap: Optional keyword arguments for function
528 L{pygeodesy.euclidean}, overriding the default mean
529 C{radius} of this point's datum ellipsoid.
531 @return: Distance (C{meter}, same units as B{C{radius}}).
533 @raise TypeError: The B{C{other}} point is not C{LatLon}.
535 @see: Function L{pygeodesy.euclidean} and methods L{cosineAndoyerLambertTo},
536 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
537 L{equirectangularTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},
538 L{haversineTo}, L{thomasTo} and L{vincentysTo}.
539 '''
540 return self._distanceTo(euclidean, other, **radius_adjust_wrap)
542 def flatLocalTo(self, other, radius=None, wrap=False):
543 '''Compute the distance between this and an other point using the
544 U{ellipsoidal Earth to plane projection
545 <https://WikiPedia.org/wiki/Geographical_distance#Ellipsoidal_Earth_projected_to_a_plane>}
546 aka U{Hubeny<https://www.OVG.AT/de/vgi/files/pdf/3781/>} formula.
548 @arg other: The other point (C{LatLon}).
549 @kwarg radius: Mean earth radius (C{meter}) or C{None} for
550 the I{equatorial radius} of this point's
551 datum ellipsoid.
552 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
553 the B{C{other}} point (C{bool}).
555 @return: Distance (C{meter}, same units as B{C{radius}}).
557 @raise TypeError: The B{C{other}} point is not C{LatLon}.
559 @raise ValueError: Invalid B{C{radius}}.
561 @see: Function L{pygeodesy.flatLocal}/L{pygeodesy.hubeny}, methods
562 L{cosineAndoyerLambertTo}, L{cosineForsytheAndoyerLambertTo},
563 L{cosineLawTo}, C{distanceTo*}, L{equirectangularTo}, L{euclideanTo},
564 L{flatPolarTo}, L{haversineTo}, L{thomasTo} and L{vincentysTo} and
565 U{local, flat Earth approximation<https://www.edwilliams.org/avform.htm#flat>}.
566 '''
567 return self._distanceTo_(flatLocal_, other, wrap=wrap, radius=
568 radius if radius in (None, R_M, _1_0, 1) else Radius(radius)) # PYCHOK kwargs
570 hubenyTo = flatLocalTo # for Karl Hubeny
572 def flatPolarTo(self, other, **radius_wrap):
573 '''Compute the distance between this and an other point using
574 the U{polar coordinate flat-Earth<https://WikiPedia.org/wiki/
575 Geographical_distance#Polar_coordinate_flat-Earth_formula>} formula.
577 @arg other: The other point (C{LatLon}).
578 @kwarg radius_wrap: Optional keyword arguments for function
579 L{pygeodesy.flatPolar}, overriding the
580 default mean C{radius} of this point's
581 datum ellipsoid.
583 @return: Distance (C{meter}, same units as B{C{radius}}).
585 @raise TypeError: The B{C{other}} point is not C{LatLon}.
587 @see: Function L{pygeodesy.flatPolar} and methods L{cosineAndoyerLambertTo},
588 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
589 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
590 L{haversineTo}, L{thomasTo} and L{vincentysTo}.
591 '''
592 return self._distanceTo(flatPolar, other, **radius_wrap)
594 def hartzell(self, los=None, earth=None):
595 '''Compute the intersection of a Line-Of-Sight (los) from this Point-Of-View
596 (pov) with this point's ellipsoid surface.
598 @kwarg los: Line-Of-Sight, I{direction} to earth (L{Vector3d}) or
599 C{None} to point to the ellipsoid's center.
600 @kwarg earth: The earth model (L{Datum}, L{Ellipsoid}, L{Ellipsoid2},
601 L{a_f2Tuple} or C{scalar} radius in C{meter}) overriding
602 this point's C{datum} ellipsoid.
604 @return: The ellipsoid intersection (C{LatLon}) or this very instance
605 if this C{pov's height} is C{0}.
607 @raise IntersectionError: Null C{pov} or B{C{los}} vector, this
608 C{pov's height} is negative or B{C{los}}
609 points outside the ellipsoid or in an
610 opposite direction.
612 @raise TypeError: Invalid B{C{los}}.
614 @see: Function C{hartzell} for further details.
615 '''
616 h = self.height
617 if not h:
618 r = self
619 elif h < 0:
620 raise IntersectionError(pov=self, los=los, height=h, txt=_no_(_height_))
621 elif los is None:
622 d = self.datum if earth is None else _spherical_datum(earth)
623 r = self.dup(datum=d, height=0, name=self.hartzell.__name__)
624 else:
625 c = self.toCartesian()
626 r = hartzell(c, los=los, earth=earth or self.datum, LatLon=self.classof)
627 return r
629 def haversineTo(self, other, **radius_wrap):
630 '''Compute the distance between this and an other point using the
631 U{Haversine<https://www.Movable-Type.co.UK/scripts/latlong.html>}
632 formula.
634 @arg other: The other point (C{LatLon}).
635 @kwarg radius_wrap: Optional keyword arguments for function
636 L{pygeodesy.haversine}, overriding the
637 default mean C{radius} of this point's
638 datum ellipsoid.
640 @return: Distance (C{meter}, same units as B{C{radius}}).
642 @raise TypeError: The B{C{other}} point is not C{LatLon}.
644 @see: Function L{pygeodesy.haversine} and methods L{cosineAndoyerLambertTo},
645 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
646 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
647 L{flatPolarTo}, L{thomasTo} and L{vincentysTo}.
648 '''
649 return self._distanceTo(haversine, other, **radius_wrap)
651 def _havg(self, other, f=_0_5, h=None):
652 '''(INTERNAL) Weighted, average height.
654 @arg other: An other point (C{LatLon}).
655 @kwarg f: Optional fraction (C{float}).
656 @kwarg h: Overriding height (C{meter}).
658 @return: Average, fractional height (C{float}) or
659 the overriding B{C{height}} (C{Height}).
660 '''
661 return Height(h) if h is not None else \
662 _MODS.fmath.favg(self.height, other.height, f=f)
664 @Property
665 def height(self):
666 '''Get the height (C{meter}).
667 '''
668 return self._height
670 @height.setter # PYCHOK setter!
671 def height(self, height):
672 '''Set the height (C{meter}).
674 @raise TypeError: Invalid B{C{height}} C{type}.
676 @raise ValueError: Invalid B{C{height}}.
677 '''
678 h = Height(height)
679 if self._height != h:
680 _update_all(self)
681 self._height = h
683 def _heigHt(self, height):
684 '''(INTERNAL) Overriding this C{height}.
685 '''
686 return self.height if height is None else Height(height)
688 def height4(self, earth=None, normal=True, LatLon=None, **LatLon_kwds):
689 '''Compute the height above or below and the projection of this point
690 on this datum's or on an other earth's ellipsoid surface.
692 @kwarg earth: A datum, ellipsoid, triaxial ellipsoid or earth radius
693 I{overriding} this datum (L{Datum}, L{Ellipsoid},
694 L{Ellipsoid2}, L{a_f2Tuple}, L{Triaxial}, L{Triaxial_},
695 L{JacobiConformal} or C{meter}, conventionally).
696 @kwarg normal: If C{True} the projection is the nearest point on the
697 ellipsoid's surface, otherwise the intersection of the
698 radial line to the center and the ellipsoid's surface.
699 @kwarg LatLon: Optional class to return the height and projection
700 (C{LatLon}) or C{None}.
701 @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,
702 ignored if C{B{LatLon} is None}.
704 @note: Use keyword argument C{height=0} to override C{B{LatLon}.height}
705 to {0} or any other C{scalar}, conventionally in C{meter}.
707 @return: An instance of B{C{LatLon}} or if C{B{LatLon} is None}, a
708 L{Vector4Tuple}C{(x, y, z, h)} with the I{projection} C{x}, C{y}
709 and C{z} coordinates and height C{h} in C{meter}, conventionally.
711 @raise TriaxialError: No convergence in triaxial root finding.
713 @raise TypeError: Invalid B{C{earth}}.
715 @see: L{Ellipsoid.height4} and L{Triaxial_.height4} for more information.
716 '''
717 c = self.toCartesian()
718 if LatLon is None:
719 r = c.height4(earth=earth, normal=normal)
720 else:
721 r = c.height4(earth=earth, normal=normal, Cartesian=c.classof, height=0)
722 r = r.toLatLon(LatLon=LatLon, **_xkwds(LatLon_kwds, height=r.height))
723 return r
725 def heightStr(self, prec=-2, m=_m_):
726 '''Return this point's B{C{height}} as C{str}ing.
728 @kwarg prec: Number of (decimal) digits, unstripped (C{int}).
729 @kwarg m: Optional unit of the height (C{str}).
731 @see: Function L{pygeodesy.hstr}.
732 '''
733 return _MODS.streprs.hstr(self.height, prec=prec, m=m)
735 @deprecated_method
736 def isantipode(self, other, eps=EPS): # PYCHOK no cover
737 '''DEPRECATED, use method L{isantipodeTo}.'''
738 return self.isantipodeTo(other, eps=eps)
740 def isantipodeTo(self, other, eps=EPS):
741 '''Check whether this and an other point are antipodal,
742 on diametrically opposite sides of the earth.
744 @arg other: The other point (C{LatLon}).
745 @kwarg eps: Tolerance for near-equality (C{degrees}).
747 @return: C{True} if points are antipodal within the given
748 tolerance, C{False} otherwise.
749 '''
750 p = self.others(other)
751 return isantipode(*(self.latlon + p.latlon), eps=eps)
753 @Property_RO
754 def isEllipsoidal(self):
755 '''Check whether this point is ellipsoidal (C{bool} or C{None} if unknown).
756 '''
757 return self.datum.isEllipsoidal if self._datum else None
759 @Property_RO
760 def isEllipsoidalLatLon(self):
761 '''Get C{LatLon} base.
762 '''
763 return False
765 def isequalTo(self, other, eps=None):
766 '''Compare this point with an other point, I{ignoring} height.
768 @arg other: The other point (C{LatLon}).
769 @kwarg eps: Tolerance for equality (C{degrees}).
771 @return: C{True} if both points are identical,
772 I{ignoring} height, C{False} otherwise.
774 @raise TypeError: The B{C{other}} point is not C{LatLon}
775 or mismatch of the B{C{other}} and
776 this C{class} or C{type}.
778 @raise UnitError: Invalid B{C{eps}}.
780 @see: Method L{isequalTo3}.
781 '''
782 return _isequalTo(self, self.others(other), eps=eps)
784 def isequalTo3(self, other, eps=None):
785 '''Compare this point with an other point, I{including} height.
787 @arg other: The other point (C{LatLon}).
788 @kwarg eps: Tolerance for equality (C{degrees}).
790 @return: C{True} if both points are identical
791 I{including} height, C{False} otherwise.
793 @raise TypeError: The B{C{other}} point is not C{LatLon}
794 or mismatch of the B{C{other}} and
795 this C{class} or C{type}.
797 @see: Method L{isequalTo}.
798 '''
799 return self.height == self.others(other).height and \
800 _isequalTo(self, other, eps=eps)
802 @Property_RO
803 def isnormal(self):
804 '''Return C{True} if this point is normal (C{bool}),
805 meaning C{abs(lat) <= 90} and C{abs(lon) <= 180}.
807 @see: Methods L{normal}, L{toNormal} and functions
808 L{pygeodesy.isnormal} and L{pygeodesy.normal}.
809 '''
810 return isnormal(self.lat, self.lon, eps=0)
812 @Property_RO
813 def isSpherical(self):
814 '''Check whether this point is spherical (C{bool} or C{None} if unknown).
815 '''
816 return self.datum.isSpherical if self._datum else None
818 @Property_RO
819 def lam(self):
820 '''Get the longitude (B{C{radians}}).
821 '''
822 return radians(self.lon)
824 @Property
825 def lat(self):
826 '''Get the latitude (C{degrees90}).
827 '''
828 return self._lat
830 @lat.setter # PYCHOK setter!
831 def lat(self, lat):
832 '''Set the latitude (C{str[N|S]} or C{degrees}).
834 @raise ValueError: Invalid B{C{lat}}.
835 '''
836 lat = Lat(lat) # parseDMS(lat, suffix=_NS_, clip=90)
837 if self._lat != lat:
838 _update_all(self)
839 self._lat = lat
841 @Property
842 def latlon(self):
843 '''Get the lat- and longitude (L{LatLon2Tuple}C{(lat, lon)}).
844 '''
845 return LatLon2Tuple(self._lat, self._lon, name=self.name)
847 @latlon.setter # PYCHOK setter!
848 def latlon(self, latlonh):
849 '''Set the lat- and longitude and optionally the height
850 (2- or 3-tuple or comma- or space-separated C{str}
851 of C{degrees90}, C{degrees180} and C{meter}).
853 @raise TypeError: Height of B{C{latlonh}} not C{scalar} or
854 B{C{latlonh}} not C{list} or C{tuple}.
856 @raise ValueError: Invalid B{C{latlonh}} or M{len(latlonh)}.
858 @see: Function L{pygeodesy.parse3llh} to parse a B{C{latlonh}}
859 string into a 3-tuple C{(lat, lon, h)}.
860 '''
861 if isstr(latlonh):
862 latlonh = parse3llh(latlonh, height=self.height)
863 else:
864 _xinstanceof(list, tuple, latlonh=latlonh)
865 if len(latlonh) == 3:
866 h = Height(latlonh[2], name=Fmt.SQUARE(latlonh=2))
867 elif len(latlonh) != 2:
868 raise _ValueError(latlonh=latlonh)
869 else:
870 h = self.height
872 llh = Lat(latlonh[0]), Lon(latlonh[1]), h # parseDMS2(latlonh[0], latlonh[1])
873 if (self._lat, self._lon, self._height) != llh:
874 _update_all(self)
875 self._lat, self._lon, self._height = llh
877 def latlon2(self, ndigits=0):
878 '''Return this point's lat- and longitude in C{degrees}, rounded.
880 @kwarg ndigits: Number of (decimal) digits (C{int}).
882 @return: A L{LatLon2Tuple}C{(lat, lon)}, both C{float}
883 and rounded away from zero.
885 @note: The C{round}ed values are always C{float}, also
886 if B{C{ndigits}} is omitted.
887 '''
888 return LatLon2Tuple(round(self.lat, ndigits),
889 round(self.lon, ndigits), name=self.name)
891 @deprecated_method
892 def latlon_(self, ndigits=0): # PYCHOK no cover
893 '''DEPRECATED, use method L{latlon2}.'''
894 return self.latlon2(ndigits=ndigits)
896 latlon2round = latlon_ # PYCHOK no cover
898 @Property
899 def latlonheight(self):
900 '''Get the lat-, longitude and height (L{LatLon3Tuple}C{(lat, lon, height)}).
901 '''
902 return self.latlon.to3Tuple(self.height)
904 @latlonheight.setter # PYCHOK setter!
905 def latlonheight(self, latlonh):
906 '''Set the lat- and longitude and optionally the height
907 (2- or 3-tuple or comma- or space-separated C{str}
908 of C{degrees90}, C{degrees180} and C{meter}).
910 @see: Property L{latlon} for more details.
911 '''
912 self.latlon = latlonh
914 @Property
915 def lon(self):
916 '''Get the longitude (C{degrees180}).
917 '''
918 return self._lon
920 @lon.setter # PYCHOK setter!
921 def lon(self, lon):
922 '''Set the longitude (C{str[E|W]} or C{degrees}).
924 @raise ValueError: Invalid B{C{lon}}.
925 '''
926 lon = Lon(lon) # parseDMS(lon, suffix=_EW_, clip=180)
927 if self._lon != lon:
928 _update_all(self)
929 self._lon = lon
931 @Property_RO
932 def _ltp(self):
933 '''(INTERNAL) Cache for L{toLtp}.
934 '''
935 return _MODS.ltp.Ltp(self, ecef=self.Ecef(self.datum), name=self.name)
937 def nearestOn6(self, points, closed=False, height=None, wrap=False):
938 '''Locate the point on a path or polygon closest to this point.
940 Points are converted to and distances are computed in
941 I{geocentric}, cartesian space.
943 @arg points: The path or polygon points (C{LatLon}[]).
944 @kwarg closed: Optionally, close the polygon (C{bool}).
945 @kwarg height: Optional height, overriding the height of
946 this and all other points (C{meter}). If
947 C{None}, take the height of points into
948 account for distances.
949 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
950 the B{C{points}} (C{bool}).
952 @return: A L{NearestOn6Tuple}C{(closest, distance, fi, j,
953 start, end)} with the C{closest}, the C{start}
954 and the C{end} point each an instance of this
955 C{LatLon} and C{distance} in C{meter}, same
956 units as the cartesian axes.
958 @raise PointsError: Insufficient number of B{C{points}}.
960 @raise TypeError: Some B{C{points}} or some B{C{points}}'
961 C{Ecef} invalid.
963 @raise ValueError: Some B{C{points}}' C{Ecef} is incompatible.
965 @see: Function L{pygeodesy.nearestOn6}.
966 '''
967 def _cs(Ps, h, w, C):
968 p = None # not used
969 for i, q in Ps.enumerate():
970 if w and i:
971 q = _unrollon(p, q)
972 yield C(height=h, i=i, up=3, points=q)
973 p = q
975 C = self._toCartesianEcef # to verify datum and Ecef
976 Ps = self.PointsIter(points, wrap=wrap)
978 c = C(height=height, this=self) # this Cartesian
979 t = nearestOn6(c, _cs(Ps, height, wrap, C), closed=closed)
980 c, s, e = t.closest, t.start, t.end
982 kwds = _xkwds_not(None, LatLon=self.classof, # this LatLon
983 height=height)
984 _r = self.Ecef(self.datum).reverse
985 p = _r(c).toLatLon(**kwds)
986 s = _r(s).toLatLon(**kwds) if s is not c else p
987 e = _r(e).toLatLon(**kwds) if e is not c else p
988 return t.dup(closest=p, start=s, end=e)
990 def normal(self):
991 '''Normalize this point I{in-place} to C{abs(lat) <= 90} and
992 C{abs(lon) <= 180}.
994 @return: C{True} if this point was I{normal}, C{False} if it
995 wasn't (but is now).
997 @see: Property L{isnormal} and method L{toNormal}.
998 '''
999 n = self.isnormal
1000 if not n:
1001 self.latlon = normal(*self.latlon)
1002 return n
1004 @Property_RO
1005 def _N_vector(self):
1006 '''(INTERNAL) Get the (C{nvectorBase._N_vector_})
1007 '''
1008 return _MODS.nvectorBase._N_vector_(*self.xyzh)
1010 @Property_RO
1011 def phi(self):
1012 '''Get the latitude (B{C{radians}}).
1013 '''
1014 return radians(self.lat)
1016 @Property_RO
1017 def philam(self):
1018 '''Get the lat- and longitude (L{PhiLam2Tuple}C{(phi, lam)}).
1019 '''
1020 return PhiLam2Tuple(self.phi, self.lam, name=self.name)
1022 def philam2(self, ndigits=0):
1023 '''Return this point's lat- and longitude in C{radians}, rounded.
1025 @kwarg ndigits: Number of (decimal) digits (C{int}).
1027 @return: A L{PhiLam2Tuple}C{(phi, lam)}, both C{float}
1028 and rounded away from zero.
1030 @note: The C{round}ed values are always C{float}, also
1031 if B{C{ndigits}} is omitted.
1032 '''
1033 return PhiLam2Tuple(round(self.phi, ndigits),
1034 round(self.lam, ndigits), name=self.name)
1036 @Property_RO
1037 def philamheight(self):
1038 '''Get the lat-, longitude in C{radians} and height (L{PhiLam3Tuple}C{(phi, lam, height)}).
1039 '''
1040 return self.philam.to3Tuple(self.height)
1042 @deprecated_method
1043 def points(self, points, closed=True): # PYCHOK no cover
1044 '''DEPRECATED, use method L{points2}.'''
1045 return self.points2(points, closed=closed)
1047 def points2(self, points, closed=True):
1048 '''Check a path or polygon represented by points.
1050 @arg points: The path or polygon points (C{LatLon}[])
1051 @kwarg closed: Optionally, consider the polygon closed,
1052 ignoring any duplicate or closing final
1053 B{C{points}} (C{bool}).
1055 @return: A L{Points2Tuple}C{(number, points)}, an C{int}
1056 and C{list} or C{tuple}.
1058 @raise PointsError: Insufficient number of B{C{points}}.
1060 @raise TypeError: Some B{C{points}} are not C{LatLon}.
1061 '''
1062 return _MODS.iters.points2(points, closed=closed, base=self)
1064 def PointsIter(self, points, loop=0, dedup=False, wrap=False):
1065 '''Return a C{PointsIter} iterator.
1067 @arg points: The path or polygon points (C{LatLon}[])
1068 @kwarg loop: Number of loop-back points (non-negative C{int}).
1069 @kwarg dedup: Skip duplicate points (C{bool}).
1070 @kwarg wrap: If C{True}, wrap or I{normalize} the
1071 enum-/iterated B{C{points}} (C{bool}).
1073 @return: A new C{PointsIter} iterator.
1075 @raise PointsError: Insufficient number of B{C{points}}.
1076 '''
1077 return PointsIter(points, base=self, loop=loop, dedup=dedup, wrap=wrap)
1079 def radii11(self, point2, point3, wrap=False):
1080 '''Return the radii of the C{Circum-}, C{In-}, I{Soddy} and C{Tangent}
1081 circles of a (planar) triangle formed by this and two other points.
1083 @arg point2: Second point (C{LatLon}).
1084 @arg point3: Third point (C{LatLon}).
1085 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{point2}} and
1086 B{C{point3}} (C{bool}).
1088 @return: L{Radii11Tuple}C{(rA, rB, rC, cR, rIn, riS, roS, a, b, c, s)}.
1090 @raise IntersectionError: Near-coincident or -colinear points.
1092 @raise TypeError: Invalid B{C{point2}} or B{C{point3}}.
1094 @see: Function L{pygeodesy.radii11}, U{Incircle
1095 <https://MathWorld.Wolfram.com/Incircle.html>}, U{Soddy Circles
1096 <https://MathWorld.Wolfram.com/SoddyCircles.html>} and U{Tangent
1097 Circles<https://MathWorld.Wolfram.com/TangentCircles.html>}.
1098 '''
1099 with _toCartesian3(self, point2, point3, wrap) as cs:
1100 return _radii11ABC(*cs, useZ=True)[0]
1102 def _rhumbx3(self, exact, radius): # != .sphericalBase._rhumbs3
1103 '''(INTERNAL) Get the C{rhumb} for this point's datum or for
1104 the earth model or earth B{C{radius}} if not C{None}.
1105 '''
1106 D = self.datum if radius is None else _spherical_datum(radius) # ellipsoidal OK
1107 x = _MODS.rhumbx # XXX Property_RO?
1108 r = D.ellipsoid.rhumbx if exact else \
1109 x.Rhumb(D, exact=False, name=D.name)
1110 return r, D, x.Caps
1112 def rhumbAzimuthTo(self, other, exact=False, radius=None, wrap=False):
1113 '''Return the azimuth (bearing) of a rhumb line (loxodrome)
1114 between this and an other (ellipsoidal) point.
1116 @arg other: The other point (C{LatLon}).
1117 @kwarg exact: If C{True}, use the I{exact} L{Rhumb} (C{bool}),
1118 default C{False}.
1119 @kwarg radius: Optional earth radius (C{meter}) or earth model
1120 (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or
1121 L{a_f2Tuple}), overriding this point's datum.
1122 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
1123 B{C{other}} point (C{bool}).
1125 @return: Rhumb azimuth (compass C{degrees360}).
1127 @raise TypeError: The B{C{other}} point is incompatible or
1128 B{C{radius}} is invalid.
1129 '''
1130 r, _, C = self._rhumbx3(exact, radius)
1131 return r._Inverse(self, other, wrap, outmask=C.AZIMUTH).azi12
1133 def rhumbDestination(self, distance, azimuth, exact=False, radius=None, height=None):
1134 '''Return the destination point having travelled the given distance
1135 from this point along a rhumb line (loxodrome) at the given azimuth.
1137 @arg distance: Distance travelled (C{meter}, same units as this
1138 point's datum (ellipsoid) axes or B{C{radius}},
1139 may be negative.
1140 @arg azimuth: Azimuth (bearing) at this point (compass C{degrees}).
1141 @kwarg exact: If C{True}, use the I{exact} L{Rhumb} (C{bool}),
1142 default C{False}.
1143 @kwarg radius: Optional earth radius (C{meter}) or earth model
1144 (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or
1145 L{a_f2Tuple}), overriding this point's datum.
1146 @kwarg height: Optional height, overriding the default height
1147 (C{meter}).
1149 @return: The destination point (ellipsoidal C{LatLon}).
1151 @raise TypeError: Invalid B{C{radius}}.
1153 @raise ValueError: Invalid B{C{distance}}, B{C{azimuth}},
1154 B{C{radius}} or B{C{height}}.
1155 '''
1156 r, D, _ = self._rhumbx3(exact, radius)
1157 d = r._Direct(self, azimuth, distance)
1158 h = self._heigHt(height)
1159 return self.classof(d.lat2, d.lon2, datum=D, height=h)
1161 def rhumbDistanceTo(self, other, exact=False, radius=None, wrap=False):
1162 '''Return the distance from this to an other point along
1163 a rhumb line (loxodrome).
1165 @arg other: The other point (C{LatLon}).
1166 @kwarg exact: If C{True}, use the I{exact} L{Rhumb} (C{bool}),
1167 default C{False}.
1168 @kwarg radius: Optional earth radius (C{meter}) or earth model
1169 (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or
1170 L{a_f2Tuple}), overriding this point's datum.
1171 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
1172 B{C{other}} point (C{bool}).
1174 @return: Distance (C{meter}, the same units as this point's
1175 datum (ellipsoid) axes or B{C{radius}}.
1177 @raise TypeError: The B{C{other}} point is incompatible or
1178 B{C{radius}} is invalid.
1180 @raise ValueError: Invalid B{C{radius}}.
1181 '''
1182 r, _, C = self._rhumbx3(exact, radius)
1183 return r._Inverse(self, other, wrap, outmask=C.DISTANCE).s12
1185 def rhumbLine(self, azimuth_other, exact=False, radius=None, wrap=False,
1186 **name_caps):
1187 '''Get a rhumb line through this point at a given azimuth or
1188 through this and an other point.
1190 @arg azimuth_other: The azimuth of the rhumb line (compass
1191 C{degrees}) or the other point (C{LatLon}).
1192 @kwarg exact: If C{True}, use the I{exact} L{Rhumb} (C{bool}),
1193 default C{False}.
1194 @kwarg radius: Optional earth radius (C{meter}) or earth model
1195 (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or
1196 L{a_f2Tuple}), overriding this point's datum.
1197 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
1198 C{azimuth_B{other}} point (C{bool}).
1199 @kwarg name_caps: Optional C{B{name}=str} and C{caps}, see
1200 L{RhumbLine} C{B{caps}}.
1202 @return: A L{RhumbLine} instance.
1204 @raise TypeError: Invalid B{C{radius}} or BC{C{azimuth_other}}
1205 not a C{scalar} nor a C{LatLon}.
1207 @see: Classes L{RhumbLine} and L{Rhumb}, property L{Rhumb.exact}
1208 and methods L{Rhumb.DirectLine} and L{Rhumb.InverseLine}.
1209 '''
1210 r, _, _ = self._rhumbx3(exact, radius)
1211 a, kwds = azimuth_other, _xkwds(name_caps, name=self.name)
1212 if isscalar(a):
1213 r = r._DirectLine(self, a, **kwds)
1214 elif isinstance(a, LatLonBase):
1215 r = r._InverseLine(self, a, wrap, **kwds)
1216 else:
1217 raise _TypeError(azimuth_other=a)
1218 return r
1220 def rhumbMidpointTo(self, other, exact=False, radius=None,
1221 height=None, fraction=_0_5, wrap=False):
1222 '''Return the (loxodromic) midpoint on the rhumb line between
1223 this and an other point.
1225 @arg other: The other point (C{LatLon}).
1226 @kwarg exact: If C{True}, use the I{exact} L{Rhumb} (C{bool}),
1227 default C{False}.
1228 @kwarg radius: Optional earth radius (C{meter}) or earth model
1229 (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or
1230 L{a_f2Tuple}), overriding this point's datum.
1231 @kwarg height: Optional height, overriding the mean height
1232 (C{meter}).
1233 @kwarg fraction: Midpoint location from this point (C{scalar}),
1234 may be negative or greater than 1.0.
1235 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
1236 B{C{other}} point (C{bool}).
1238 @return: The midpoint at the given B{C{fraction}} along the
1239 rhumb line (C{LatLon}).
1241 @raise TypeError: The B{C{other}} point is incompatible or
1242 B{C{radius}} is invalid.
1244 @raise ValueError: Invalid B{C{height}} or B{C{fraction}}.
1245 '''
1246 r, D, _ = self._rhumbx3(exact, radius)
1247 f = Scalar(fraction=fraction)
1248 d = r._Inverse(self, other, wrap) # C.AZIMUTH_DISTANCE
1249 d = r._Direct( self, d.azi12, d.s12 * f)
1250 h = self._havg(other, f=f, h=height)
1251 return self.classof(d.lat2, d.lon2, datum=D, height=h)
1253 def thomasTo(self, other, wrap=False):
1254 '''Compute the distance between this and an other point using
1255 U{Thomas'<https://apps.DTIC.mil/dtic/tr/fulltext/u2/703541.pdf>}
1256 formula.
1258 @arg other: The other point (C{LatLon}).
1259 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
1260 the B{C{other}} point (C{bool}).
1262 @return: Distance (C{meter}, same units as the axes of
1263 this point's datum ellipsoid).
1265 @raise TypeError: The B{C{other}} point is not C{LatLon}.
1267 @see: Function L{pygeodesy.thomas} and methods L{cosineAndoyerLambertTo},
1268 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
1269 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
1270 L{flatPolarTo}, L{haversineTo} and L{vincentysTo}.
1271 '''
1272 return self._distanceTo_(thomas_, other, wrap=wrap)
1274 @deprecated_method
1275 def to2ab(self): # PYCHOK no cover
1276 '''DEPRECATED, use property L{philam}.'''
1277 return self.philam
1279 def toCartesian(self, height=None, Cartesian=None, **Cartesian_kwds):
1280 '''Convert this point to cartesian, I{geocentric} coordinates,
1281 also known as I{Earth-Centered, Earth-Fixed} (ECEF).
1283 @kwarg height: Optional height, overriding this point's height
1284 (C{meter}, conventionally).
1285 @kwarg Cartesian: Optional class to return the geocentric
1286 coordinates (C{Cartesian}) or C{None}.
1287 @kwarg Cartesian_kwds: Optional, additional B{C{Cartesian}}
1288 keyword arguments, ignored if
1289 C{B{Cartesian} is None}.
1291 @return: A B{C{Cartesian}} or if B{C{Cartesian}} is C{None},
1292 an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M,
1293 datum)} with C{C=0} and C{M} if available.
1295 @raise TypeError: Invalid B{C{Cartesian}} or B{C{Cartesian_kwds}}.
1296 '''
1297 r = self._ecef9 if height is None else self.toEcef(height=height)
1298 if Cartesian is not None: # class or .classof
1299 r = self._xnamed(Cartesian(r, **Cartesian_kwds))
1300 _xdatum(r.datum, self.datum)
1301 return r
1303 def _toCartesianEcef(self, height=None, i=None, up=2, **name_point):
1304 '''(INTERNAL) Convert to cartesian and check Ecef's before and after.
1305 '''
1306 p = self.others(up=up, **name_point)
1307 c = p.toCartesian(height=height)
1308 E = self.Ecef
1309 if E:
1310 for p in (p, c):
1311 e = getattr(p, LatLonBase.Ecef.name, None)
1312 if e not in (None, E): # PYCHOK no cover
1313 n, _ = name_point.popitem()
1314 if i is not None:
1315 Fmt.SQUARE(n, i)
1316 raise _ValueError(n, e, txt=_incompatible(E.__name__))
1317 return c
1319 def toEcef(self, height=None, M=False):
1320 '''Convert this point to I{geocentric} coordinates, also known as
1321 I{Earth-Centered, Earth-Fixed} (U{ECEF<https://WikiPedia.org/wiki/ECEF>}).
1323 @kwarg height: Optional height, overriding this point's height
1324 (C{meter}, conventionally).
1325 @kwarg M: Optionally, include the rotation L{EcefMatrix} (C{bool}).
1327 @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
1328 with C{C=0} and C{M} if available.
1330 @raise EcefError: A C{.datum} or an ECEF issue.
1331 '''
1332 return self._ecef9 if height in (None, self.height) else \
1333 self._Ecef_forward(self.lat, self.lon, height=height, M=M)
1335 @deprecated_method
1336 def to3llh(self, height=None): # PYCHOK no cover
1337 '''DEPRECATED, use property L{latlonheight} or C{latlon.to3Tuple(B{height})}.'''
1338 return self.latlonheight if height in (None, self.height) else \
1339 self.latlon.to3Tuple(height)
1341 def toLocal(self, Xyz=None, ltp=None, **Xyz_kwds):
1342 '''Convert this I{geodetic} point to I{local} C{X}, C{Y} and C{Z}.
1344 @kwarg Xyz: Optional class to return C{X}, C{Y} and C{Z}
1345 (L{XyzLocal}, L{Enu}, L{Ned}) or C{None}.
1346 @kwarg ltp: The I{local tangent plane} (LTP) to use,
1347 overriding this point's LTP (L{Ltp}).
1348 @kwarg Xyz_kwds: Optional, additional B{C{Xyz}} keyword
1349 arguments, ignored if C{B{Xyz} is None}.
1351 @return: An B{C{Xyz}} instance or if C{B{Xyz} is None},
1352 a L{Local9Tuple}C{(x, y, z, lat, lon, height,
1353 ltp, ecef, M)} with C{M=None}, always.
1355 @raise TypeError: Invalid B{C{ltp}}.
1356 '''
1357 p = _MODS.ltp._xLtp(ltp, self._ltp)
1358 return p._ecef2local(self._ecef9, Xyz, Xyz_kwds)
1360 def toLtp(self, Ecef=None):
1361 '''Return the I{local tangent plane} (LTP) for this point.
1363 @kwarg Ecef: Optional ECEF I{class} (L{EcefKarney}, ...
1364 L{EcefYou}), overriding this point's C{Ecef}.
1365 '''
1366 return self._ltp if Ecef in (None, self.Ecef) else _MODS.ltp.Ltp(
1367 self, ecef=Ecef(self.datum), name=self.name)
1369 def toNormal(self, deep=False, name=NN):
1370 '''Get this point I{normalized} to C{abs(lat) <= 90}
1371 and C{abs(lon) <= 180}.
1373 @kwarg deep: If C{True} make a deep, otherwise a
1374 shallow copy (C{bool}).
1375 @kwarg name: Optional name of the copy (C{str}).
1377 @return: A copy of this point, I{normalized} and
1378 optionally renamed (C{LatLon}).
1380 @see: Property L{isnormal}, method L{normal} and function
1381 L{pygeodesy.normal}.
1382 '''
1383 ll = self.copy(deep=deep)
1384 _ = ll.normal()
1385 if name:
1386 ll.rename(name)
1387 return ll
1389 def toNvector(self, h=None, Nvector=None, **Nvector_kwds):
1390 '''Convert this point to C{n-vector} (normal to the earth's surface)
1391 components, I{including height}.
1393 @kwarg h: Optional height, overriding this point's
1394 height (C{meter}).
1395 @kwarg Nvector: Optional class to return the C{n-vector}
1396 components (C{Nvector}) or C{None}.
1397 @kwarg Nvector_kwds_wrap: Optional, additional B{C{Nvector}}
1398 keyword arguments, ignored if C{B{Nvector}
1399 is None}.
1401 @return: A B{C{Nvector}} or a L{Vector4Tuple}C{(x, y, z, h)}
1402 if B{C{Nvector}} is C{None}.
1404 @raise TypeError: Invalid B{C{Nvector}} or B{C{Nvector_kwds}}.
1405 '''
1406 return self.toVector(Vector=Nvector, h=self.height if h is None else h,
1407 ll=self, **Nvector_kwds)
1409 def toStr(self, form=F_DMS, joined=_COMMASPACE_, m=_m_, **prec_sep_s_D_M_S): # PYCHOK expected
1410 '''Convert this point to a "lat, lon[, +/-height]" string, formatted
1411 in the given C{B{form}at}.
1413 @kwarg form: The lat-/longitude C{B{form}at} to use (C{str}), see
1414 functions L{pygeodesy.latDMS} or L{pygeodesy.lonDMS}.
1415 @kwarg joined: Separator to join the lat-, longitude and heigth
1416 strings (C{str} or C{None} or C{NN} for non-joined).
1417 @kwarg m: Optional unit of the height (C{str}), use C{None} to
1418 exclude height from the returned string.
1419 @kwarg prec_sep_s_D_M_S: Optional C{B{prec}ision}, C{B{sep}arator},
1420 B{C{s_D}}, B{C{s_M}}, B{C{s_S}} and B{C{s_DMS}} keyword
1421 arguments, see function L{pygeodesy.latDMS} or
1422 L{pygeodesy.lonDMS}.
1424 @return: This point in the specified C{B{form}at}, etc. (C{str} or
1425 a 2- or 3-tuple C{(lat_str, lon_str[, height_str])} if
1426 C{B{joined}=NN} or C{B{joined}=None}).
1428 @see: Function L{pygeodesy.latDMS} or L{pygeodesy.lonDMS} for more
1429 details about keyword arguments C{B{form}at}, C{B{prec}ision},
1430 C{B{sep}arator}, B{C{s_D}}, B{C{s_M}}, B{C{s_S}} and B{C{s_DMS}}.
1432 @example:
1434 >>> LatLon(51.4778, -0.0016).toStr() # 51°28′40″N, 000°00′06″W
1435 >>> LatLon(51.4778, -0.0016).toStr(F_D) # 51.4778°N, 000.0016°W
1436 >>> LatLon(51.4778, -0.0016, 42).toStr() # 51°28′40″N, 000°00′06″W, +42.00m
1437 '''
1438 t = (latDMS(self.lat, form=form, **prec_sep_s_D_M_S),
1439 lonDMS(self.lon, form=form, **prec_sep_s_D_M_S))
1440 if self.height and m is not None:
1441 t += (self.heightStr(m=m),)
1442 return joined.join(t) if joined else t
1444 def toVector(self, Vector=None, **Vector_kwds):
1445 '''Convert this point to C{n-vector} (normal to the earth's
1446 surface) components, I{ignoring height}.
1448 @kwarg Vector: Optional class to return the C{n-vector}
1449 components (L{Vector3d}) or C{None}.
1450 @kwarg Vector_kwds: Optional, additional B{C{Vector}}
1451 keyword arguments, ignored if
1452 C{B{Vector} is None}.
1454 @return: A B{C{Vector}} or a L{Vector3Tuple}C{(x, y, z)}
1455 if B{C{Vector}} is C{None}.
1457 @raise TypeError: Invalid B{C{Vector}} or B{C{kwds}}.
1459 @note: These are C{n-vector} x, y and z components,
1460 I{NOT} geocentric (ECEF) x, y and z coordinates!
1461 '''
1462 r = self._vector3tuple
1463 if Vector is not None:
1464 r = Vector(*r, **_xkwds(Vector_kwds, name=self.name))
1465 return r
1467 def toVector3d(self):
1468 '''Convert this point to C{n-vector} (normal to the earth's
1469 surface) components, I{ignoring height}.
1471 @return: Unit vector (L{Vector3d}).
1473 @note: These are C{n-vector} x, y and z components,
1474 I{NOT} geocentric (ECEF) x, y and z coordinates!
1475 '''
1476 return self._vector3d # XXX .unit()
1478 def toWm(self, **toWm_kwds):
1479 '''Convert this point to a WM coordinate.
1481 @kwarg toWm_kwds: Optional L{pygeodesy.toWm} keyword arguments.
1483 @return: The WM coordinate (L{Wm}).
1485 @see: Function L{pygeodesy.toWm}.
1486 '''
1487 return self._wm if not toWm_kwds else _MODS.webmercator.toWm(
1488 self, **_xkwds(toWm_kwds, name=self.name))
1490 @deprecated_method
1491 def to3xyz(self): # PYCHOK no cover
1492 '''DEPRECATED, use property L{xyz} or method L{toNvector}, L{toVector},
1493 L{toVector3d} or perhaps (geocentric) L{toEcef}.'''
1494 return self.xyz # self.toVector()
1496 @Property_RO
1497 def _vector3d(self):
1498 '''(INTERNAL) Cache for L{toVector3d}.
1499 '''
1500 return self.toVector(Vector=Vector3d) # XXX .unit()
1502 @Property_RO
1503 def _vector3tuple(self):
1504 '''(INTERNAL) Cache for L{toVector}.
1505 '''
1506 return philam2n_xyz(self.phi, self.lam, name=self.name)
1508 def vincentysTo(self, other, **radius_wrap):
1509 '''Compute the distance between this and an other point using
1510 U{Vincenty's<https://WikiPedia.org/wiki/Great-circle_distance>}
1511 spherical formula.
1513 @arg other: The other point (C{LatLon}).
1514 @kwarg radius_wrap: Optional keyword arguments for function
1515 L{pygeodesy.vincentys}, overriding the
1516 default mean C{radius} of this point's
1517 datum ellipsoid.
1519 @return: Distance (C{meter}, same units as B{C{radius}}).
1521 @raise TypeError: The B{C{other}} point is not C{LatLon}.
1523 @see: Function L{pygeodesy.vincentys} and methods L{cosineAndoyerLambertTo},
1524 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},
1525 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},
1526 L{flatPolarTo}, L{haversineTo} and L{thomasTo}.
1527 '''
1528 return self._distanceTo(vincentys, other, **_xkwds(radius_wrap, radius=None))
1530 @Property_RO
1531 def _wm(self):
1532 '''(INTERNAL) Get this point as webmercator (L{Wm}).
1533 '''
1534 return _MODS.webmercator.toWm(self)
1536 @Property_RO
1537 def xyz(self):
1538 '''Get the C{n-vector} X, Y and Z components (L{Vector3Tuple}C{(x, y, z)})
1540 @note: These are C{n-vector} x, y and z components, I{NOT}
1541 geocentric (ECEF) x, y and z coordinates!
1542 '''
1543 return self.toVector(Vector=Vector3Tuple)
1545 @Property_RO
1546 def xyzh(self):
1547 '''Get the C{n-vector} X, Y, Z and H components (L{Vector4Tuple}C{(x, y, z, h)})
1549 @note: These are C{n-vector} x, y and z components, I{NOT}
1550 geocentric (ECEF) x, y and z coordinates!
1551 '''
1552 return self.xyz.to4Tuple(self.height)
1555class _toCartesian3(object): # see also .geodesicw._wargs, .vector2d._numpy
1556 '''(INTERNAL) Wrapper to convert 2 other points.
1557 '''
1558 @contextmanager # <https://www.python.org/dev/peps/pep-0343/> Examples
1559 def __call__(self, p, p2, p3, wrap, **kwds):
1560 try:
1561 if wrap:
1562 p2, p3 = map1(_Wrap.point, p2, p3)
1563 kwds = _xkwds(kwds, wrap=wrap)
1564 yield (p. toCartesian().copy(name=_point_), # copy to rename
1565 p._toCartesianEcef(up=4, point2=p2),
1566 p._toCartesianEcef(up=4, point3=p3))
1567 except (AssertionError, TypeError, ValueError) as x:
1568 raise _xError(x, point=p, point2=p2, point3=p3, **kwds)
1570_toCartesian3 = _toCartesian3() # PYCHOK singleton
1573def _trilaterate5(p1, d1, p2, d2, p3, d3, area=True, eps=EPS1, # MCCABE 13
1574 radius=R_M, wrap=False):
1575 '''(INTERNAL) Trilaterate three points by area overlap or by
1576 perimeter intersection of three circles.
1578 @note: The B{C{radius}} is only needed for both the n-vectorial
1579 and C{sphericalTrigonometry.LatLon.distanceTo} methods and
1580 silently ignored by the C{ellipsoidalExact}, C{-GeodSolve},
1581 C{-Karney} and C{-Vincenty.LatLon.distanceTo} methods.
1582 '''
1583 p2, p3, w = _unrollon3(p1, p2, p3, wrap)
1585 r1 = Distance_(distance1=d1)
1586 r2 = Distance_(distance2=d2)
1587 r3 = Distance_(distance3=d3)
1588 m = 0 if area else (r1 + r2 + r3)
1589 pc = 0
1590 t = []
1591 for _ in range(3):
1592 try: # intersection of circle (p1, r1) and (p2, r2)
1593 c1, c2 = p1.intersections2(r1, p2, r2, wrap=w)
1595 if area: # check overlap
1596 if c1 is c2: # abutting
1597 c = c1
1598 else: # nearest point on radical
1599 c = p3.nearestOn(c1, c2, within=True, wrap=w)
1600 d = r3 - p3.distanceTo(c, radius=radius, wrap=w)
1601 if d > eps: # sufficient overlap
1602 t.append((d, c))
1603 m = max(m, d)
1605 else: # check intersection
1606 for c in ((c1,) if c1 is c2 else (c1, c2)):
1607 d = fabs(r3 - p3.distanceTo(c, radius=radius, wrap=w))
1608 if d < eps: # below margin
1609 t.append((d, c))
1610 m = min(m, d)
1612 except IntersectionError as x:
1613 if _concentric_ in str(x): # XXX ConcentricError?
1614 pc += 1
1616 p1, r1, p2, r2, p3, r3 = p2, r2, p3, r3, p1, r1 # rotate
1618 if t: # get min, max, points and count ...
1619 t = tuple(sorted(t))
1620 n = len(t), # as 1-tuple
1621 # ... or for a single trilaterated result,
1622 # min *is* max, min- *is* maxPoint and n=1, 2 or 3
1623 return Trilaterate5Tuple(t[0] + t[-1] + n) # *(t[0] + ...)
1625 elif area and pc == 3: # all pairwise concentric ...
1626 r, p = min((r1, p1), (r2, p2), (r3, p3))
1627 m = max(r1, r2, r3)
1628 # ... return "smallest" point twice, the smallest
1629 # and largest distance and n=0 for concentric
1630 return Trilaterate5Tuple(float(r), p, float(m), p, 0)
1632 n, f = (_overlap_, max) if area else (_intersection_, min)
1633 t = _COMMASPACE_(_no_(n), '%s %.3g' % (f.__name__, m))
1634 raise IntersectionError(area=area, eps=eps, wrap=wrap, txt=t)
1637__all__ += _ALL_DOCS(LatLonBase)
1639# **) MIT License
1640#
1641# Copyright (C) 2016-2023 -- mrJean1 at Gmail -- All Rights Reserved.
1642#
1643# Permission is hereby granted, free of charge, to any person obtaining a
1644# copy of this software and associated documentation files (the "Software"),
1645# to deal in the Software without restriction, including without limitation
1646# the rights to use, copy, modify, merge, publish, distribute, sublicense,
1647# and/or sell copies of the Software, and to permit persons to whom the
1648# Software is furnished to do so, subject to the following conditions:
1649#
1650# The above copyright notice and this permission notice shall be included
1651# in all copies or substantial portions of the Software.
1652#
1653# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
1654# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1655# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
1656# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
1657# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
1658# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
1659# OTHER DEALINGS IN THE SOFTWARE.