1

2# -*- coding: utf-8 -*-

3

4 u'''(INTERNAL) Base class L{LatLonBase} for all elliposiodal, spherical and N-vectorial C{LatLon} classes.

5

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'''

12

13 from pygeodesy.basics import isscalar, isstr, map1, _xinstanceof

14 from pygeodesy.constants import EPS, EPS0, EPS1, EPS4, INT0, R_M, \

15 _0_0, _0_5, _1_0

16# from pygeodesy.datums import _spherical_datum # from .formy

17 from pygeodesy.dms import F_D, F_DMS, latDMS, lonDMS, parse3llh

18# from pygeodesy.ecef import EcefKarney # _MODS

19 from pygeodesy.errors import _incompatible, IntersectionError, _IsnotError, \

20 _TypeError, _ValueError, _xdatum, _xError, \

21 _xkwds, _xkwds_not

22# from pygeodesy.fmath import favg # _MODS

23 from pygeodesy.formy import antipode, compassAngle, cosineAndoyerLambert_, \

24 cosineForsytheAndoyerLambert_, cosineLaw, \

25 equirectangular, euclidean, flatLocal_, \

26 flatPolar, hartzell, haversine, isantipode, \

27 _isequalTo, isnormal, normal, philam2n_xyz, \

28 thomas_, vincentys, _spherical_datum

29 from pygeodesy.interns import NN, _COMMASPACE_, _concentric_, _height_, \

30 _intersection_, _m_, _LatLon_, _no_, \

31 _overlap_, _point_ # PYCHOK used!

32# from pygeodesy.iters import PointsIter, points2 # from .vector3d, _MODS

33# from pygeodesy.karney import Caps # _MODS

34 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS

35# from pygeodesy.ltp import Ltp, _xLtp # _MODS

36 from pygeodesy.named import _NamedBase, notOverloaded, Fmt

37 from pygeodesy.namedTuples import Bounds2Tuple, LatLon2Tuple, PhiLam2Tuple, \

38 Trilaterate5Tuple, Vector3Tuple

39# from pygeodesy.nvectorBase import _N_vector_ # _MODS

40 from pygeodesy.props import deprecated_method, Property, Property_RO, \

41 property_RO, _update_all

42# from pygeodesy.streprs import Fmt, hstr # from .named, _MODS

43 from pygeodesy.units import Distance_, Lat, Lon, Height, Radius, Radius_, \

44 Scalar, Scalar_

45 from pygeodesy.utily import _unrollon, _unrollon3, _Wrap

46 from pygeodesy.vector2d import _circin6, Circin6Tuple, _circum3, circum4_, \

47 Circum3Tuple, _radii11ABC

48 from pygeodesy.vector3d import nearestOn6, Vector3d, PointsIter

49

50 from contextlib import contextmanager

51 from math import asin, cos, degrees, fabs, radians

52

53__all__ = _ALL_LAZY.latlonBase

54__version__ = '23.09.09'

55

56

57 class LatLonBase(_NamedBase):

58 '''(INTERNAL) Base class for C{LatLon} points on spherical or

59 ellipsoidal earth models.

60 '''

61 _clipid = INT0 # polygonal clip, see .booleans

62 _datum = None # L{Datum}, to be overriden

63 _height = INT0 # height (C{meter}), default

64 _lat = 0 # latitude (C{degrees})

65 _lon = 0 # longitude (C{degrees})

66

67 def __init__(self, latlonh, lon=None, height=0, wrap=False, name=NN):

68 '''New C{LatLon}.

69

70 @arg latlonh: Latitude (C{degrees} or DMS C{str} with N or S suffix) or

71 a previous C{LatLon} instance provided C{B{lon}=None}.

72 @kwarg lon: Longitude (C{degrees} or DMS C{str} with E or W suffix) or

73 C(None), indicating B{C{latlonh}} is a C{LatLon}.

74 @kwarg height: Optional height above (or below) the earth surface

75 (C{meter}, conventionally).

76 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}}

77 (C{bool}).

78 @kwarg name: Optional name (C{str}).

79

80 @return: New instance (C{LatLon}).

81

82 @raise RangeError: A B{C{lon}} or C{lat} value outside the valid

83 range and L{rangerrors} set to C{True}.

84

85 @raise TypeError: If B{C{latlonh}} is not a C{LatLon}.

86

87 @raise UnitError: Invalid B{C{lat}}, B{C{lon}} or B{C{height}}.

88

89 @example:

90

91 >>> p = LatLon(50.06632, -5.71475)

92 >>> q = LatLon('50°03′59″N', """005°42'53"W""")

93 >>> r = LatLon(p)

94 '''

95 if name:

96 self.name = name

97

98 if lon is None:

99 try:

100 lat, lon = latlonh.lat, latlonh.lon

101 height = latlonh.get(_height_, height)

102 except AttributeError:

103 raise _IsnotError(_LatLon_, latlonh=latlonh)

104 if wrap:

105 lat, lon = _Wrap.latlon(lat, lon)

106 elif wrap:

107 lat, lon = _Wrap.latlonDMS2(latlonh, lon)

108 else:

109 lat = latlonh

110

111 self._lat = Lat(lat) # parseDMS2(lat, lon)

112 self._lon = Lon(lon) # PYCHOK LatLon2Tuple

113 if height: # elevation

114 self._height = Height(height)

115

116 def __eq__(self, other):

117 return self.isequalTo(other)

118

119 def __ne__(self, other):

120 return not self.isequalTo(other)

121

122 def __str__(self):

123 return self.toStr(form=F_D, prec=6)

124

125 def antipode(self, height=None):

126 '''Return the antipode, the point diametrically opposite

127 to this point.

128

129 @kwarg height: Optional height of the antipode (C{meter}),

130 this point's height otherwise.

131

132 @return: The antipodal point (C{LatLon}).

133 '''

134 h = self._heigHt(height)

135 return self.classof(*antipode(*self.latlon), height=h)

136

137 @deprecated_method

138 def bounds(self, wide, tall, radius=R_M): # PYCHOK no cover

139 '''DEPRECATED, use method C{boundsOf}.'''

140 return self.boundsOf(wide, tall, radius=radius)

141

142 def boundsOf(self, wide, tall, radius=R_M, height=None):

143 '''Return the SW and NE lat-/longitude of a great circle

144 bounding box centered at this location.

145

146 @arg wide: Longitudinal box width (C{meter}, same units as

147 B{C{radius}} or C{degrees} if B{C{radius}} is C{None}).

148 @arg tall: Latitudinal box size (C{meter}, same units as

149 B{C{radius}} or C{degrees} if B{C{radius}} is C{None}).

150 @kwarg radius: Mean earth radius (C{meter}) or C{None} if I{both}

151 B{C{wide}} and B{C{tall}} are in C{degrees}.

152 @kwarg height: Height for C{latlonSW} and C{latlonNE} (C{meter}),

153 overriding the point's height.

154

155 @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)}, the

156 lower-left and upper-right corner (C{LatLon}).

157

158 @see: U{https://www.Movable-Type.co.UK/scripts/latlong-db.html}

159 '''

160 w = Scalar_(wide=wide) * _0_5

161 t = Scalar_(tall=tall) * _0_5

162 if radius is not None:

163 r = Radius_(radius)

164 c = cos(self.phi)

165 w = degrees(asin(w / r) / c) if fabs(c) > EPS0 else _0_0 # XXX

166 t = degrees(t / r)

167 y, t = self.lat, fabs(t)

168 x, w = self.lon, fabs(w)

169

170 h = self._heigHt(height)

171 sw = self.classof(y - t, x - w, height=h)

172 ne = self.classof(y + t, x + w, height=h)

173 return Bounds2Tuple(sw, ne, name=self.name)

174

175 def chordTo(self, other, height=None, wrap=False):

176 '''Compute the length of the chord through the earth between

177 this and an other point.

178

179 @arg other: The other point (C{LatLon}).

180 @kwarg height: Overriding height for both points (C{meter})

181 or C{None} for each point's height.

182 @kwarg wrap: If C{True}, wrap or I{normalize} the B{C{other}}

183 point (C{bool}).

184

185 @return: The chord length (conventionally C{meter}).

186

187 @raise TypeError: The B{C{other}} point is not C{LatLon}.

188 '''

189 def _v3d(ll):

190 t = ll.toEcef(height=height) # .toVector(Vector=Vector3d)

191 return Vector3d(t.x, t.y, t.z)

192

193 p = self.others(other)

194 if wrap:

195 p = _Wrap.point(p)

196 return _v3d(self).minus(_v3d(p)).length

197

198 def circin6(self, point2, point3, eps=EPS4, wrap=False):

199 '''Return the radius and center of the I{inscribed} aka I{In-}circle

200 of the (planar) triangle formed by this and two other points.

201

202 @arg point2: Second point (C{LatLon}).

203 @arg point3: Third point (C{LatLon}).

204 @kwarg eps: Tolerance for function L{pygeodesy.trilaterate3d2}.

205 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{point2}} and

206 B{C{point3}} (C{bool}).

207

208 @return: L{Circin6Tuple}C{(radius, center, deltas, cA, cB, cC)}. The

209 C{center} and contact points C{cA}, C{cB} and C{cC}, each an

210 instance of this (sub-)class, are co-planar with this and the

211 two given points, see the B{Note} below.

212

213 @raise ImportError: Package C{numpy} not found, not installed or older

214 than version 1.10.

215

216 @raise IntersectionError: Near-coincident or -colinear points or

217 a trilateration or C{numpy} issue.

218

219 @raise TypeError: Invalid B{C{point2}} or B{C{point3}}.

220

221 @note: The C{center} is trilaterated in cartesian (ECEF) space and converted

222 back to geodetic lat-, longitude and height. The latter, conventionally

223 in C{meter} indicates whether the C{center} is above, below or on the

224 surface of the earth model. If C{deltas} is C{None}, the C{center} is

225 I{un}ambigous. Otherwise C{deltas} is a L{LatLon3Tuple}C{(lat, lon,

226 height)} representing the differences between both results from

227 L{pygeodesy.trilaterate3d2} and C{center} is the mean thereof.

228

229 @see: Function L{pygeodesy.circin6}, method L{circum3}, U{Incircle

230 <https://MathWorld.Wolfram.com/Incircle.html>} and U{Contact Triangle

231 <https://MathWorld.Wolfram.com/ContactTriangle.html>}.

232 '''

233 with _toCartesian3(self, point2, point3, wrap) as cs:

234 r, c, d, cA, cB, cC = _circin6(*cs, eps=eps, useZ=True, dLL3=True,

235 datum=self.datum) # PYCHOK unpack

236 return Circin6Tuple(r, c.toLatLon(), d, cA.toLatLon(), cB.toLatLon(), cC.toLatLon())

237

238 def circum3(self, point2, point3, circum=True, eps=EPS4, wrap=False):

239 '''Return the radius and center of the smallest circle I{through} or I{containing}

240 this and two other points.

241

242 @arg point2: Second point (C{LatLon}).

243 @arg point3: Third point (C{LatLon}).

244 @kwarg circum: If C{True} return the C{circumradius} and C{circumcenter},

245 always, ignoring the I{Meeus}' Type I case (C{bool}).

246 @kwarg eps: Tolerance for function L{pygeodesy.trilaterate3d2}.

247 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{point2}} and

248 B{C{point3}} (C{bool}).

249

250 @return: A L{Circum3Tuple}C{(radius, center, deltas)}. The C{center}, an

251 instance of this (sub-)class, is co-planar with this and the two

252 given points. If C{deltas} is C{None}, the C{center} is

253 I{un}ambigous. Otherwise C{deltas} is a L{LatLon3Tuple}C{(lat,

254 lon, height)} representing the difference between both results

255 from L{pygeodesy.trilaterate3d2} and C{center} is the mean thereof.

256

257 @raise ImportError: Package C{numpy} not found, not installed or older than

258 version 1.10.

259

260 @raise IntersectionError: Near-concentric, -coincident or -colinear points,

261 incompatible C{Ecef} classes or a trilateration

262 or C{numpy} issue.

263

264 @raise TypeError: Invalid B{C{point2}} or B{C{point3}}.

265

266 @note: The C{center} is trilaterated in cartesian (ECEF) space and converted

267 back to geodetic lat-, longitude and height. The latter, conventionally

268 in C{meter} indicates whether the C{center} is above, below or on the

269 surface of the earth model. If C{deltas} is C{None}, the C{center} is

270 I{un}ambigous. Otherwise C{deltas} is a L{LatLon3Tuple}C{(lat, lon,

271 height)} representing the difference between both results from

272 L{pygeodesy.trilaterate3d2} and C{center} is the mean thereof.

273

274 @see: Function L{pygeodesy.circum3} and methods L{circin6} and L{circum4_}.

275 '''

276 with _toCartesian3(self, point2, point3, wrap, circum=circum) as cs:

277 r, c, d = _circum3(*cs, circum=circum, eps=eps, useZ=True, dLL3=True, # XXX -3d2

278 clas=cs[0].classof, datum=self.datum) # PYCHOK unpack

279 return Circum3Tuple(r, c.toLatLon(), d)

280

281 def circum4_(self, *points, **wrap):

282 '''Best-fit a sphere through this and two or more other points.

283

284 @arg points: The other points (each a C{LatLon}).

285 @kwarg wrap: If C{True}, wrap or I{normalize} the B{C{points}}

286 (C{bool}), default C{False}.

287

288 @return: L{Circum4Tuple}C{(radius, center, rank, residuals)} with C{center}

289 an instance of this (sub-)class.

290

291 @raise ImportError: Package C{numpy} not found, not installed or older than

292 version 1.10.

293

294 @raise NumPyError: Some C{numpy} issue.

295

296 @raise TypeError: One of the B{C{points}} invalid.

297

298 @raise ValueError: Too few B{C{points}}.

299

300 @see: Function L{pygeodesy.circum4_} and L{circum3}.

301 '''

302 def _cs(ps, C, wrap=False):

303 _wp = _Wrap.point if wrap else (lambda p: p)

304 for i, p in enumerate(ps):

305 yield C(i=i, points=_wp(p))

306

307 C = self._toCartesianEcef

308 c = C(point=self)

309 t = circum4_(c, Vector=c.classof, *_cs(points, C, **wrap))

310 c = t.center.toLatLon(LatLon=self.classof)

311 return t.dup(center=c)

312

313 @property

314 def clipid(self):

315 '''Get the (polygonal) clip (C{int}).

316 '''

317 return self._clipid

318

319 @clipid.setter # PYCHOK setter!

320 def clipid(self, clipid):

321 '''Get the (polygonal) clip (C{int}).

322 '''

323 self._clipid = int(clipid)

324

325 @deprecated_method

326 def compassAngle(self, other, **adjust_wrap): # PYCHOK no cover

327 '''DEPRECATED, use method L{compassAngleTo}.'''

328 return self.compassAngleTo(other, **adjust_wrap)

329

330 def compassAngleTo(self, other, **adjust_wrap):

331 '''Return the angle from North for the direction vector between

332 this and an other point.

333

334 Suitable only for short, non-near-polar vectors up to a few

335 hundred Km or Miles. Use method C{initialBearingTo} for

336 larger distances.

337

338 @arg other: The other point (C{LatLon}).

339 @kwarg adjust_wrap: Optional keyword arguments for function

340 L{pygeodesy.compassAngle}.

341

342 @return: Compass angle from North (C{degrees360}).

343

344 @raise TypeError: The B{C{other}} point is not C{LatLon}.

345

346 @note: Courtesy of Martin Schultz.

347

348 @see: U{Local, flat earth approximation

349 <https://www.EdWilliams.org/avform.htm#flat>}.

350 '''

351 p = self.others(other)

352 return compassAngle(self.lat, self.lon, p.lat, p.lon, **adjust_wrap)

353

354 def cosineAndoyerLambertTo(self, other, wrap=False):

355 '''Compute the distance between this and an other point using the U{Andoyer-Lambert correction<https://

356 navlib.net/wp-content/uploads/2013/10/admiralty-manual-of-navigation-vol-1-1964-english501c.pdf>}

357 of the U{Law of Cosines<https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>} formula.

358

359 @arg other: The other point (C{LatLon}).

360 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll

361 the B{C{other}} point (C{bool}).

362

363 @return: Distance (C{meter}, same units as the axes of this

364 point's datum ellipsoid).

365

366 @raise TypeError: The B{C{other}} point is not C{LatLon}.

367

368 @see: Function L{pygeodesy.cosineAndoyerLambert} and methods

369 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo},

370 C{distanceTo*}, L{equirectangularTo}, L{euclideanTo},

371 L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo}, L{haversineTo},

372 L{thomasTo} and L{vincentysTo}.

373 '''

374 return self._distanceTo_(cosineAndoyerLambert_, other, wrap=wrap)

375

376 def cosineForsytheAndoyerLambertTo(self, other, wrap=False):

377 '''Compute the distance between this and an other point using

378 the U{Forsythe-Andoyer-Lambert correction

379 <https://www2.UNB.Ca/gge/Pubs/TR77.pdf>} of the U{Law of Cosines

380 <https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>}

381 formula.

382

383 @arg other: The other point (C{LatLon}).

384 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll

385 the B{C{other}} point (C{bool}).

386

387 @return: Distance (C{meter}, same units as the axes of

388 this point's datum ellipsoid).

389

390 @raise TypeError: The B{C{other}} point is not C{LatLon}.

391

392 @see: Function L{pygeodesy.cosineForsytheAndoyerLambert} and methods

393 L{cosineAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},

394 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},

395 L{flatPolarTo}, L{haversineTo}, L{thomasTo} and L{vincentysTo}.

396 '''

397 return self._distanceTo_(cosineForsytheAndoyerLambert_, other, wrap=wrap)

398

399 def cosineLawTo(self, other, radius=None, wrap=False):

400 '''Compute the distance between this and an other point using the

401 U{spherical Law of Cosines

402 <https://www.Movable-Type.co.UK/scripts/latlong.html#cosine-law>}

403 formula.

404

405 @arg other: The other point (C{LatLon}).

406 @kwarg radius: Mean earth radius (C{meter}) or C{None}

407 for the mean radius of this point's datum

408 ellipsoid.

409 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll

410 the B{C{other}} point (C{bool}).

411

412 @return: Distance (C{meter}, same units as B{C{radius}}).

413

414 @raise TypeError: The B{C{other}} point is not C{LatLon}.

415

416 @see: Function L{pygeodesy.cosineLaw} and methods L{cosineAndoyerLambertTo},

417 L{cosineForsytheAndoyerLambertTo}, C{distanceTo*}, L{equirectangularTo},

418 L{euclideanTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},

419 L{haversineTo}, L{thomasTo} and L{vincentysTo}.

420 '''

421 return self._distanceTo(cosineLaw, other, radius, wrap=wrap)

422

423 @property_RO

424 def datum(self): # PYCHOK no cover

425 '''(INTERNAL) I{Must be overloaded}, see function C{notOverloaded}.

426 '''

427 notOverloaded(self)

428

429 def destinationXyz(self, delta, LatLon=None, **LatLon_kwds):

430 '''Calculate the destination using a I{local} delta from this point.

431

432 @arg delta: Local delta to the destination (L{XyzLocal}, L{Enu},

433 L{Ned} or L{Local9Tuple}).

434 @kwarg LatLon: Optional (geodetic) class to return the destination

435 or C{None}.

436 @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword

437 arguments, ignored if C{B{LatLon} is None}.

438

439 @return: Destination as a C{B{LatLon}(lat, lon, **B{LatLon_kwds})}

440 instance or if C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat,

441 lon, height)} respectively L{LatLon4Tuple}C{(lat, lon,

442 height, datum)} depending on whether a C{datum} keyword

443 is un-/specified.

444

445 @raise TypeError: Invalid B{C{delta}}, B{C{LatLon}} or B{C{LatLon_kwds}}.

446 '''

447 t = self._ltp._local2ecef(delta, nine=True)

448 return t.toLatLon(LatLon=LatLon, **_xkwds(LatLon_kwds, name=self.name))

449

450 def _distanceTo(self, func, other, radius=None, **kwds):

451 '''(INTERNAL) Helper for distance methods C{<func>To}.

452 '''

453 p, r = self.others(other, up=2), radius

454 if r is None:

455 r = self._datum.ellipsoid.R1 if self._datum else R_M

456 return func(self.lat, self.lon, p.lat, p.lon, radius=r, **kwds)

457

458 def _distanceTo_(self, func_, other, wrap=False, radius=None):

459 '''(INTERNAL) Helper for (ellipsoidal) methods C{<func>To}.

460 '''

461 p = self.others(other, up=2)

462 D = self.datum

463 lam21, phi2, _ = _Wrap.philam3(self.lam, p.phi, p.lam, wrap)

464 r = func_(phi2, self.phi, lam21, datum=D)

465 return r * (D.ellipsoid.a if radius is None else radius)

466

467 @Property_RO

468 def Ecef(self):

469 '''Get the ECEF I{class} (L{EcefKarney}), I{lazily}.

470 '''

471 return _MODS.ecef.EcefKarney # default

472

473 @Property_RO

474 def _Ecef_forward(self):

475 '''(INTERNAL) Helper for L{_ecef9} and L{toEcef} (C{callable}).

476 '''

477 return self.Ecef(self.datum, name=self.name).forward

478

479 @Property_RO

480 def _ecef9(self):

481 '''(INTERNAL) Helper for L{toCartesian}, L{toEcef} and L{toCartesian} (L{Ecef9Tuple}).

482 '''

483 return self._Ecef_forward(self, M=True)

484

485 @deprecated_method

486 def equals(self, other, eps=None): # PYCHOK no cover

487 '''DEPRECATED, use method L{isequalTo}.'''

488 return self.isequalTo(other, eps=eps)

489

490 @deprecated_method

491 def equals3(self, other, eps=None): # PYCHOK no cover

492 '''DEPRECATED, use method L{isequalTo3}.'''

493 return self.isequalTo3(other, eps=eps)

494

495 def equirectangularTo(self, other, **radius_adjust_limit_wrap):

496 '''Compute the distance between this and an other point

497 using the U{Equirectangular Approximation / Projection

498 <https://www.Movable-Type.co.UK/scripts/latlong.html#equirectangular>}.

499

500 Suitable only for short, non-near-polar distances up to a

501 few hundred Km or Miles. Use method L{haversineTo} or

502 C{distanceTo*} for more accurate and/or larger distances.

503

504 @arg other: The other point (C{LatLon}).

505 @kwarg radius_adjust_limit_wrap: Optional keyword arguments

506 for function L{pygeodesy.equirectangular},

507 overriding the default mean C{radius} of this

508 point's datum ellipsoid.

509

510 @return: Distance (C{meter}, same units as B{C{radius}}).

511

512 @raise TypeError: The B{C{other}} point is not C{LatLon}.

513

514 @see: Function L{pygeodesy.equirectangular} and methods L{cosineAndoyerLambertTo},

515 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},

516 C{euclideanTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},

517 L{haversineTo}, L{thomasTo} and L{vincentysTo}.

518 '''

519 return self._distanceTo(equirectangular, other, **radius_adjust_limit_wrap)

520

521 def euclideanTo(self, other, **radius_adjust_wrap):

522 '''Approximate the C{Euclidian} distance between this and

523 an other point.

524

525 See function L{pygeodesy.euclidean} for the available B{C{options}}.

526

527 @arg other: The other point (C{LatLon}).

528 @kwarg radius_adjust_wrap: Optional keyword arguments for function

529 L{pygeodesy.euclidean}, overriding the default mean

530 C{radius} of this point's datum ellipsoid.

531

532 @return: Distance (C{meter}, same units as B{C{radius}}).

533

534 @raise TypeError: The B{C{other}} point is not C{LatLon}.

535

536 @see: Function L{pygeodesy.euclidean} and methods L{cosineAndoyerLambertTo},

537 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},

538 L{equirectangularTo}, L{flatLocalTo}/L{hubenyTo}, L{flatPolarTo},

539 L{haversineTo}, L{thomasTo} and L{vincentysTo}.

540 '''

541 return self._distanceTo(euclidean, other, **radius_adjust_wrap)

542

543 def flatLocalTo(self, other, radius=None, wrap=False):

544 '''Compute the distance between this and an other point using the

545 U{ellipsoidal Earth to plane projection

546 <https://WikiPedia.org/wiki/Geographical_distance#Ellipsoidal_Earth_projected_to_a_plane>}

547 aka U{Hubeny<https://www.OVG.AT/de/vgi/files/pdf/3781/>} formula.

548

549 @arg other: The other point (C{LatLon}).

550 @kwarg radius: Mean earth radius (C{meter}) or C{None} for

551 the I{equatorial radius} of this point's

552 datum ellipsoid.

553 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll

554 the B{C{other}} point (C{bool}).

555

556 @return: Distance (C{meter}, same units as B{C{radius}}).

557

558 @raise TypeError: The B{C{other}} point is not C{LatLon}.

559

560 @raise ValueError: Invalid B{C{radius}}.

561

562 @see: Function L{pygeodesy.flatLocal}/L{pygeodesy.hubeny}, methods

563 L{cosineAndoyerLambertTo}, L{cosineForsytheAndoyerLambertTo},

564 L{cosineLawTo}, C{distanceTo*}, L{equirectangularTo}, L{euclideanTo},

565 L{flatPolarTo}, L{haversineTo}, L{thomasTo} and L{vincentysTo} and

566 U{local, flat Earth approximation<https://www.edwilliams.org/avform.htm#flat>}.

567 '''

568 return self._distanceTo_(flatLocal_, other, wrap=wrap, radius=

569 radius if radius in (None, R_M, _1_0, 1) else Radius(radius)) # PYCHOK kwargs

570

571 hubenyTo = flatLocalTo # for Karl Hubeny

572

573 def flatPolarTo(self, other, **radius_wrap):

574 '''Compute the distance between this and an other point using

575 the U{polar coordinate flat-Earth<https://WikiPedia.org/wiki/

576 Geographical_distance#Polar_coordinate_flat-Earth_formula>} formula.

577

578 @arg other: The other point (C{LatLon}).

579 @kwarg radius_wrap: Optional keyword arguments for function

580 L{pygeodesy.flatPolar}, overriding the

581 default mean C{radius} of this point's

582 datum ellipsoid.

583

584 @return: Distance (C{meter}, same units as B{C{radius}}).

585

586 @raise TypeError: The B{C{other}} point is not C{LatLon}.

587

588 @see: Function L{pygeodesy.flatPolar} and methods L{cosineAndoyerLambertTo},

589 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},

590 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},

591 L{haversineTo}, L{thomasTo} and L{vincentysTo}.

592 '''

593 return self._distanceTo(flatPolar, other, **radius_wrap)

594

595 def hartzell(self, los=None, earth=None):

596 '''Compute the intersection of a Line-Of-Sight (los) from this Point-Of-View

597 (pov) with this point's ellipsoid surface.

598

599 @kwarg los: Line-Of-Sight, I{direction} to earth (L{Vector3d}) or

600 C{None} to point to the ellipsoid's center.

601 @kwarg earth: The earth model (L{Datum}, L{Ellipsoid}, L{Ellipsoid2},

602 L{a_f2Tuple} or C{scalar} radius in C{meter}) overriding

603 this point's C{datum} ellipsoid.

604

605 @return: The ellipsoid intersection (C{LatLon}) or this very instance

606 if this C{pov's height} is C{0}.

607

608 @raise IntersectionError: Null C{pov} or B{C{los}} vector, this

609 C{pov's height} is negative or B{C{los}}

610 points outside the ellipsoid or in an

611 opposite direction.

612

613 @raise TypeError: Invalid B{C{los}}.

614

615 @see: Function C{hartzell} for further details.

616 '''

617 h = self.height

618 if not h:

619 r = self

620 elif h < 0:

621 raise IntersectionError(pov=self, los=los, height=h, txt=_no_(_height_))

622 elif los is None:

623 d = self.datum if earth is None else _spherical_datum(earth)

624 r = self.dup(datum=d, height=0, name=self.hartzell.__name__)

625 else:

626 c = self.toCartesian()

627 r = hartzell(c, los=los, earth=earth or self.datum, LatLon=self.classof)

628 return r

629

630 def haversineTo(self, other, **radius_wrap):

631 '''Compute the distance between this and an other point using the

632 U{Haversine<https://www.Movable-Type.co.UK/scripts/latlong.html>}

633 formula.

634

635 @arg other: The other point (C{LatLon}).

636 @kwarg radius_wrap: Optional keyword arguments for function

637 L{pygeodesy.haversine}, overriding the

638 default mean C{radius} of this point's

639 datum ellipsoid.

640

641 @return: Distance (C{meter}, same units as B{C{radius}}).

642

643 @raise TypeError: The B{C{other}} point is not C{LatLon}.

644

645 @see: Function L{pygeodesy.haversine} and methods L{cosineAndoyerLambertTo},

646 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},

647 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},

648 L{flatPolarTo}, L{thomasTo} and L{vincentysTo}.

649 '''

650 return self._distanceTo(haversine, other, **radius_wrap)

651

652 def _havg(self, other, f=_0_5, h=None):

653 '''(INTERNAL) Weighted, average height.

654

655 @arg other: An other point (C{LatLon}).

656 @kwarg f: Optional fraction (C{float}).

657 @kwarg h: Overriding height (C{meter}).

658

659 @return: Average, fractional height (C{float}) or

660 the overriding B{C{height}} (C{Height}).

661 '''

662 return Height(h) if h is not None else \

663 _MODS.fmath.favg(self.height, other.height, f=f)

664

665 @Property

666 def height(self):

667 '''Get the height (C{meter}).

668 '''

669 return self._height

670

671 @height.setter # PYCHOK setter!

672 def height(self, height):

673 '''Set the height (C{meter}).

674

675 @raise TypeError: Invalid B{C{height}} C{type}.

676

677 @raise ValueError: Invalid B{C{height}}.

678 '''

679 h = Height(height)

680 if self._height != h:

681 _update_all(self)

682 self._height = h

683

684 def _heigHt(self, height):

685 '''(INTERNAL) Overriding this C{height}.

686 '''

687 return self.height if height is None else Height(height)

688

689 def height4(self, earth=None, normal=True, LatLon=None, **LatLon_kwds):

690 '''Compute the height above or below and the projection of this point

691 on this datum's or on an other earth's ellipsoid surface.

692

693 @kwarg earth: A datum, ellipsoid, triaxial ellipsoid or earth radius

694 I{overriding} this datum (L{Datum}, L{Ellipsoid},

695 L{Ellipsoid2}, L{a_f2Tuple}, L{Triaxial}, L{Triaxial_},

696 L{JacobiConformal} or C{meter}, conventionally).

697 @kwarg normal: If C{True} the projection is the nearest point on the

698 ellipsoid's surface, otherwise the intersection of the

699 radial line to the center and the ellipsoid's surface.

700 @kwarg LatLon: Optional class to return the height and projection

701 (C{LatLon}) or C{None}.

702 @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,

703 ignored if C{B{LatLon} is None}.

704

705 @note: Use keyword argument C{height=0} to override C{B{LatLon}.height}

706 to {0} or any other C{scalar}, conventionally in C{meter}.

707

708 @return: An instance of B{C{LatLon}} or if C{B{LatLon} is None}, a

709 L{Vector4Tuple}C{(x, y, z, h)} with the I{projection} C{x}, C{y}

710 and C{z} coordinates and height C{h} in C{meter}, conventionally.

711

712 @raise TriaxialError: No convergence in triaxial root finding.

713

714 @raise TypeError: Invalid B{C{earth}}.

715

716 @see: L{Ellipsoid.height4} and L{Triaxial_.height4} for more information.

717 '''

718 c = self.toCartesian()

719 if LatLon is None:

720 r = c.height4(earth=earth, normal=normal)

721 else:

722 r = c.height4(earth=earth, normal=normal, Cartesian=c.classof, height=0)

723 r = r.toLatLon(LatLon=LatLon, **_xkwds(LatLon_kwds, height=r.height))

724 return r

725

726 def heightStr(self, prec=-2, m=_m_):

727 '''Return this point's B{C{height}} as C{str}ing.

728

729 @kwarg prec: Number of (decimal) digits, unstripped (C{int}).

730 @kwarg m: Optional unit of the height (C{str}).

731

732 @see: Function L{pygeodesy.hstr}.

733 '''

734 return _MODS.streprs.hstr(self.height, prec=prec, m=m)

735

736 @deprecated_method

737 def isantipode(self, other, eps=EPS): # PYCHOK no cover

738 '''DEPRECATED, use method L{isantipodeTo}.'''

739 return self.isantipodeTo(other, eps=eps)

740

741 def isantipodeTo(self, other, eps=EPS):

742 '''Check whether this and an other point are antipodal,

743 on diametrically opposite sides of the earth.

744

745 @arg other: The other point (C{LatLon}).

746 @kwarg eps: Tolerance for near-equality (C{degrees}).

747

748 @return: C{True} if points are antipodal within the given

749 tolerance, C{False} otherwise.

750 '''

751 p = self.others(other)

752 return isantipode(*(self.latlon + p.latlon), eps=eps)

753

754 @Property_RO

755 def isEllipsoidal(self):

756 '''Check whether this point is ellipsoidal (C{bool} or C{None} if unknown).

757 '''

758 return self.datum.isEllipsoidal if self._datum else None

759

760 @Property_RO

761 def isEllipsoidalLatLon(self):

762 '''Get C{LatLon} base.

763 '''

764 return False

765

766 def isequalTo(self, other, eps=None):

767 '''Compare this point with an other point, I{ignoring} height.

768

769 @arg other: The other point (C{LatLon}).

770 @kwarg eps: Tolerance for equality (C{degrees}).

771

772 @return: C{True} if both points are identical,

773 I{ignoring} height, C{False} otherwise.

774

775 @raise TypeError: The B{C{other}} point is not C{LatLon}

776 or mismatch of the B{C{other}} and

777 this C{class} or C{type}.

778

779 @raise UnitError: Invalid B{C{eps}}.

780

781 @see: Method L{isequalTo3}.

782 '''

783 return _isequalTo(self, self.others(other), eps=eps)

784

785 def isequalTo3(self, other, eps=None):

786 '''Compare this point with an other point, I{including} height.

787

788 @arg other: The other point (C{LatLon}).

789 @kwarg eps: Tolerance for equality (C{degrees}).

790

791 @return: C{True} if both points are identical

792 I{including} height, C{False} otherwise.

793

794 @raise TypeError: The B{C{other}} point is not C{LatLon}

795 or mismatch of the B{C{other}} and

796 this C{class} or C{type}.

797

798 @see: Method L{isequalTo}.

799 '''

800 return self.height == self.others(other).height and \

801 _isequalTo(self, other, eps=eps)

802

803 @Property_RO

804 def isnormal(self):

805 '''Return C{True} if this point is normal (C{bool}),

806 meaning C{abs(lat) <= 90} and C{abs(lon) <= 180}.

807

808 @see: Methods L{normal}, L{toNormal} and functions

809 L{pygeodesy.isnormal} and L{pygeodesy.normal}.

810 '''

811 return isnormal(self.lat, self.lon, eps=0)

812

813 @Property_RO

814 def isSpherical(self):

815 '''Check whether this point is spherical (C{bool} or C{None} if unknown).

816 '''

817 return self.datum.isSpherical if self._datum else None

818

819 @Property_RO

820 def lam(self):

821 '''Get the longitude (B{C{radians}}).

822 '''

823 return radians(self.lon)

824

825 @Property

826 def lat(self):

827 '''Get the latitude (C{degrees90}).

828 '''

829 return self._lat

830

831 @lat.setter # PYCHOK setter!

832 def lat(self, lat):

833 '''Set the latitude (C{str[N|S]} or C{degrees}).

834

835 @raise ValueError: Invalid B{C{lat}}.

836 '''

837 lat = Lat(lat) # parseDMS(lat, suffix=_NS_, clip=90)

838 if self._lat != lat:

839 _update_all(self)

840 self._lat = lat

841

842 @Property

843 def latlon(self):

844 '''Get the lat- and longitude (L{LatLon2Tuple}C{(lat, lon)}).

845 '''

846 return LatLon2Tuple(self._lat, self._lon, name=self.name)

847

848 @latlon.setter # PYCHOK setter!

849 def latlon(self, latlonh):

850 '''Set the lat- and longitude and optionally the height

851 (2- or 3-tuple or comma- or space-separated C{str}

852 of C{degrees90}, C{degrees180} and C{meter}).

853

854 @raise TypeError: Height of B{C{latlonh}} not C{scalar} or

855 B{C{latlonh}} not C{list} or C{tuple}.

856

857 @raise ValueError: Invalid B{C{latlonh}} or M{len(latlonh)}.

858

859 @see: Function L{pygeodesy.parse3llh} to parse a B{C{latlonh}}

860 string into a 3-tuple C{(lat, lon, h)}.

861 '''

862 if isstr(latlonh):

863 latlonh = parse3llh(latlonh, height=self.height)

864 else:

865 _xinstanceof(list, tuple, latlonh=latlonh)

866 if len(latlonh) == 3:

867 h = Height(latlonh[2], name=Fmt.SQUARE(latlonh=2))

868 elif len(latlonh) != 2:

869 raise _ValueError(latlonh=latlonh)

870 else:

871 h = self.height

872

873 llh = Lat(latlonh[0]), Lon(latlonh[1]), h # parseDMS2(latlonh[0], latlonh[1])

874 if (self._lat, self._lon, self._height) != llh:

875 _update_all(self)

876 self._lat, self._lon, self._height = llh

877

878 def latlon2(self, ndigits=0):

879 '''Return this point's lat- and longitude in C{degrees}, rounded.

880

881 @kwarg ndigits: Number of (decimal) digits (C{int}).

882

883 @return: A L{LatLon2Tuple}C{(lat, lon)}, both C{float}

884 and rounded away from zero.

885

886 @note: The C{round}ed values are always C{float}, also

887 if B{C{ndigits}} is omitted.

888 '''

889 return LatLon2Tuple(round(self.lat, ndigits),

890 round(self.lon, ndigits), name=self.name)

891

892 @deprecated_method

893 def latlon_(self, ndigits=0): # PYCHOK no cover

894 '''DEPRECATED, use method L{latlon2}.'''

895 return self.latlon2(ndigits=ndigits)

896

897 latlon2round = latlon_ # PYCHOK no cover

898

899 @Property

900 def latlonheight(self):

901 '''Get the lat-, longitude and height (L{LatLon3Tuple}C{(lat, lon, height)}).

902 '''

903 return self.latlon.to3Tuple(self.height)

904

905 @latlonheight.setter # PYCHOK setter!

906 def latlonheight(self, latlonh):

907 '''Set the lat- and longitude and optionally the height

908 (2- or 3-tuple or comma- or space-separated C{str}

909 of C{degrees90}, C{degrees180} and C{meter}).

910

911 @see: Property L{latlon} for more details.

912 '''

913 self.latlon = latlonh

914

915 @Property

916 def lon(self):

917 '''Get the longitude (C{degrees180}).

918 '''

919 return self._lon

920

921 @lon.setter # PYCHOK setter!

922 def lon(self, lon):

923 '''Set the longitude (C{str[E|W]} or C{degrees}).

924

925 @raise ValueError: Invalid B{C{lon}}.

926 '''

927 lon = Lon(lon) # parseDMS(lon, suffix=_EW_, clip=180)

928 if self._lon != lon:

929 _update_all(self)

930 self._lon = lon

931

932 @Property_RO

933 def _ltp(self):

934 '''(INTERNAL) Cache for L{toLtp}.

935 '''

936 return _MODS.ltp.Ltp(self, ecef=self.Ecef(self.datum), name=self.name)

937

938 def nearestOn6(self, points, closed=False, height=None, wrap=False):

939 '''Locate the point on a path or polygon closest to this point.

940

941 Points are converted to and distances are computed in

942 I{geocentric}, cartesian space.

943

944 @arg points: The path or polygon points (C{LatLon}[]).

945 @kwarg closed: Optionally, close the polygon (C{bool}).

946 @kwarg height: Optional height, overriding the height of

947 this and all other points (C{meter}). If

948 C{None}, take the height of points into

949 account for distances.

950 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll

951 the B{C{points}} (C{bool}).

952

953 @return: A L{NearestOn6Tuple}C{(closest, distance, fi, j,

954 start, end)} with the C{closest}, the C{start}

955 and the C{end} point each an instance of this

956 C{LatLon} and C{distance} in C{meter}, same

957 units as the cartesian axes.

958

959 @raise PointsError: Insufficient number of B{C{points}}.

960

961 @raise TypeError: Some B{C{points}} or some B{C{points}}'

962 C{Ecef} invalid.

963

964 @raise ValueError: Some B{C{points}}' C{Ecef} is incompatible.

965

966 @see: Function L{pygeodesy.nearestOn6}.

967 '''

968 def _cs(Ps, h, w, C):

969 p = None # not used

970 for i, q in Ps.enumerate():

971 if w and i:

972 q = _unrollon(p, q)

973 yield C(height=h, i=i, up=3, points=q)

974 p = q

975

976 C = self._toCartesianEcef # to verify datum and Ecef

977 Ps = self.PointsIter(points, wrap=wrap)

978

979 c = C(height=height, this=self) # this Cartesian

980 t = nearestOn6(c, _cs(Ps, height, wrap, C), closed=closed)

981 c, s, e = t.closest, t.start, t.end

982

983 kwds = _xkwds_not(None, LatLon=self.classof, # this LatLon

984 height=height)

985 _r = self.Ecef(self.datum).reverse

986 p = _r(c).toLatLon(**kwds)

987 s = _r(s).toLatLon(**kwds) if s is not c else p

988 e = _r(e).toLatLon(**kwds) if e is not c else p

989 return t.dup(closest=p, start=s, end=e)

990

991 def normal(self):

992 '''Normalize this point I{in-place} to C{abs(lat) <= 90} and

993 C{abs(lon) <= 180}.

994

995 @return: C{True} if this point was I{normal}, C{False} if it

996 wasn't (but is now).

997

998 @see: Property L{isnormal} and method L{toNormal}.

999 '''

1000 n = self.isnormal

1001 if not n:

1002 self.latlon = normal(*self.latlon)

1003 return n

1004

1005 @Property_RO

1006 def _N_vector(self):

1007 '''(INTERNAL) Get the (C{nvectorBase._N_vector_})

1008 '''

1009 return _MODS.nvectorBase._N_vector_(*self.xyzh)

1010

1011 @Property_RO

1012 def phi(self):

1013 '''Get the latitude (B{C{radians}}).

1014 '''

1015 return radians(self.lat)

1016

1017 @Property_RO

1018 def philam(self):

1019 '''Get the lat- and longitude (L{PhiLam2Tuple}C{(phi, lam)}).

1020 '''

1021 return PhiLam2Tuple(self.phi, self.lam, name=self.name)

1022

1023 def philam2(self, ndigits=0):

1024 '''Return this point's lat- and longitude in C{radians}, rounded.

1025

1026 @kwarg ndigits: Number of (decimal) digits (C{int}).

1027

1028 @return: A L{PhiLam2Tuple}C{(phi, lam)}, both C{float}

1029 and rounded away from zero.

1030

1031 @note: The C{round}ed values are always C{float}, also

1032 if B{C{ndigits}} is omitted.

1033 '''

1034 return PhiLam2Tuple(round(self.phi, ndigits),

1035 round(self.lam, ndigits), name=self.name)

1036

1037 @Property_RO

1038 def philamheight(self):

1039 '''Get the lat-, longitude in C{radians} and height (L{PhiLam3Tuple}C{(phi, lam, height)}).

1040 '''

1041 return self.philam.to3Tuple(self.height)

1042

1043 @deprecated_method

1044 def points(self, points, closed=True): # PYCHOK no cover

1045 '''DEPRECATED, use method L{points2}.'''

1046 return self.points2(points, closed=closed)

1047

1048 def points2(self, points, closed=True):

1049 '''Check a path or polygon represented by points.

1050

1051 @arg points: The path or polygon points (C{LatLon}[])

1052 @kwarg closed: Optionally, consider the polygon closed,

1053 ignoring any duplicate or closing final

1054 B{C{points}} (C{bool}).

1055

1056 @return: A L{Points2Tuple}C{(number, points)}, an C{int}

1057 and C{list} or C{tuple}.

1058

1059 @raise PointsError: Insufficient number of B{C{points}}.

1060

1061 @raise TypeError: Some B{C{points}} are not C{LatLon}.

1062 '''

1063 return _MODS.iters.points2(points, closed=closed, base=self)

1064

1065 def PointsIter(self, points, loop=0, dedup=False, wrap=False):

1066 '''Return a C{PointsIter} iterator.

1067

1068 @arg points: The path or polygon points (C{LatLon}[])

1069 @kwarg loop: Number of loop-back points (non-negative C{int}).

1070 @kwarg dedup: Skip duplicate points (C{bool}).

1071 @kwarg wrap: If C{True}, wrap or I{normalize} the

1072 enum-/iterated B{C{points}} (C{bool}).

1073

1074 @return: A new C{PointsIter} iterator.

1075

1076 @raise PointsError: Insufficient number of B{C{points}}.

1077 '''

1078 return PointsIter(points, base=self, loop=loop, dedup=dedup, wrap=wrap)

1079

1080 def radii11(self, point2, point3, wrap=False):

1081 '''Return the radii of the C{Circum-}, C{In-}, I{Soddy} and C{Tangent}

1082 circles of a (planar) triangle formed by this and two other points.

1083

1084 @arg point2: Second point (C{LatLon}).

1085 @arg point3: Third point (C{LatLon}).

1086 @kwarg wrap: If C{True}, wrap or I{normalize} B{C{point2}} and

1087 B{C{point3}} (C{bool}).

1088

1089 @return: L{Radii11Tuple}C{(rA, rB, rC, cR, rIn, riS, roS, a, b, c, s)}.

1090

1091 @raise IntersectionError: Near-coincident or -colinear points.

1092

1093 @raise TypeError: Invalid B{C{point2}} or B{C{point3}}.

1094

1095 @see: Function L{pygeodesy.radii11}, U{Incircle

1096 <https://MathWorld.Wolfram.com/Incircle.html>}, U{Soddy Circles

1097 <https://MathWorld.Wolfram.com/SoddyCircles.html>} and U{Tangent

1098 Circles<https://MathWorld.Wolfram.com/TangentCircles.html>}.

1099 '''

1100 with _toCartesian3(self, point2, point3, wrap) as cs:

1101 return _radii11ABC(*cs, useZ=True)[0]

1102

1103 def _rhumb3(self, exact, radius): # != .sphericalBase._rhumbs3

1104 '''(INTERNAL) Get the C{rhumb} for this point's datum or for

1105 the B{C{radius}}' earth model iff non-C{None}.

1106 '''

1107 try:

1108 d = self._rhumb3dict

1109 t = d[(exact, radius)]

1110 except KeyError:

1111 D = self.datum if radius is None else _spherical_datum(radius) # ellipsoidal OK

1112 r = D.ellipsoid.rhumb_(exact=exact) # or D.isSpherical)

1113 t = r, D, _MODS.karney.Caps

1114 while d:

1115 d.popitem()

1116 d[(exact, radius)] = t # cache 3-tuple

1117 return t

1118

1119 @Property_RO

1120 def _rhumb3dict(self):

1121 return {} # single-item cache

1122

1123 def rhumbAzimuthTo(self, other, exact=False, radius=None, wrap=False):

1124 '''Return the azimuth (bearing) of a rhumb line (loxodrome)

1125 between this and an other (ellipsoidal) point.

1126

1127 @arg other: The other point (C{LatLon}).

1128 @kwarg exact: Exact C{Rhumb...} to use (C{bool} or C{Rhumb...}),

1129 see method L{Ellipsoid.rhumb_}.

1130 @kwarg radius: Optional earth radius (C{meter}) or earth model

1131 (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or

1132 L{a_f2Tuple}), overriding this point's datum.

1133 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the

1134 B{C{other}} point (C{bool}).

1135

1136 @return: Rhumb azimuth (compass C{degrees360}).

1137

1138 @raise TypeError: The B{C{other}} point is incompatible or

1139 B{C{radius}} is invalid.

1140 '''

1141 r, _, Cs = self._rhumb3(exact, radius)

1142 return r._Inverse(self, other, wrap, outmask=Cs.AZIMUTH).azi12

1143

1144 def rhumbDestination(self, distance, azimuth, exact=False, radius=None, height=None):

1145 '''Return the destination point having travelled the given distance

1146 from this point along a rhumb line (loxodrome) at the given azimuth.

1147

1148 @arg distance: Distance travelled (C{meter}, same units as this

1149 point's datum (ellipsoid) axes or B{C{radius}},

1150 may be negative.

1151 @arg azimuth: Azimuth (bearing) at this point (compass C{degrees}).

1152 @kwarg exact: Exact C{Rhumb...} to use (C{bool} or C{Rhumb...}),

1153 see method L{Ellipsoid.rhumb_}.

1154 @kwarg radius: Optional earth radius (C{meter}) or earth model

1155 (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or

1156 L{a_f2Tuple}), overriding this point's datum.

1157 @kwarg height: Optional height, overriding the default height

1158 (C{meter}).

1159

1160 @return: The destination point (ellipsoidal C{LatLon}).

1161

1162 @raise TypeError: Invalid B{C{radius}}.

1163

1164 @raise ValueError: Invalid B{C{distance}}, B{C{azimuth}},

1165 B{C{radius}} or B{C{height}}.

1166 '''

1167 r, D, _ = self._rhumb3(exact, radius)

1168 d = r._Direct(self, azimuth, distance)

1169 h = self._heigHt(height)

1170 return self.classof(d.lat2, d.lon2, datum=D, height=h)

1171

1172 def rhumbDistanceTo(self, other, exact=False, radius=None, wrap=False):

1173 '''Return the distance from this to an other point along

1174 a rhumb line (loxodrome).

1175

1176 @arg other: The other point (C{LatLon}).

1177 @kwarg exact: Exact C{Rhumb...} to use (C{bool} or C{Rhumb...}),

1178 see method L{Ellipsoid.rhumb_}.

1179 @kwarg radius: Optional earth radius (C{meter}) or earth model

1180 (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or

1181 L{a_f2Tuple}), overriding this point's datum.

1182 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the

1183 B{C{other}} point (C{bool}).

1184

1185 @return: Distance (C{meter}, the same units as this point's

1186 datum (ellipsoid) axes or B{C{radius}}.

1187

1188 @raise TypeError: The B{C{other}} point is incompatible or

1189 B{C{radius}} is invalid.

1190

1191 @raise ValueError: Invalid B{C{radius}}.

1192 '''

1193 r, _, Cs = self._rhumb3(exact, radius)

1194 return r._Inverse(self, other, wrap, outmask=Cs.DISTANCE).s12

1195

1196 def rhumbLine(self, azimuth_other, exact=False, radius=None, wrap=False,

1197 **name_caps):

1198 '''Get a rhumb line through this point at a given azimuth or

1199 through this and an other point.

1200

1201 @arg azimuth_other: The azimuth of the rhumb line (compass

1202 C{degrees}) or the other point (C{LatLon}).

1203 @kwarg exact: Exact C{Rhumb...} to use (C{bool} or C{Rhumb...}),

1204 see method L{Ellipsoid.rhumb_}.

1205 @kwarg radius: Optional earth radius (C{meter}) or earth model

1206 (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or

1207 L{a_f2Tuple}), overriding this point's datum.

1208 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the

1209 C{azimuth_B{other}} point (C{bool}).

1210 @kwarg name_caps: Optional C{B{name}=str} and C{caps}, see

1211 L{RhumbLine} C{B{caps}}.

1212

1213 @return: A C{RhumbLine} instance.

1214

1215 @raise TypeError: Invalid B{C{radius}} or BC{C{azimuth_other}}

1216 not a C{scalar} nor a C{LatLon}.

1217

1218 @see: Modules L{rhumbaux} and L{rhumbx}.

1219 '''

1220 r, _, _ = self._rhumb3(exact, radius)

1221 a, kwds = azimuth_other, _xkwds(name_caps, name=self.name)

1222 if isscalar(a):

1223 r = r._DirectLine(self, a, **kwds)

1224 elif isinstance(a, LatLonBase):

1225 r = r._InverseLine(self, a, wrap, **kwds)

1226 else:

1227 raise _TypeError(azimuth_other=a)

1228 return r

1229

1230 def rhumbMidpointTo(self, other, exact=False, radius=None,

1231 height=None, fraction=_0_5, wrap=False):

1232 '''Return the (loxodromic) midpoint on the rhumb line between

1233 this and an other point.

1234

1235 @arg other: The other point (C{LatLon}).

1236 @kwarg exact: Exact C{Rhumb...} to use (C{bool} or C{Rhumb...}),

1237 see method L{Ellipsoid.rhumb_}.

1238 @kwarg radius: Optional earth radius (C{meter}) or earth model

1239 (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or

1240 L{a_f2Tuple}), overriding this point's datum.

1241 @kwarg height: Optional height, overriding the mean height

1242 (C{meter}).

1243 @kwarg fraction: Midpoint location from this point (C{scalar}), 0

1244 for this, 1 for the B{C{other}}, 0.5 for halfway

1245 between this and the B{C{other}} point, may be

1246 negative or greater than 1.

1247 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the

1248 B{C{other}} point (C{bool}).

1249

1250 @return: The midpoint at the given B{C{fraction}} along the

1251 rhumb line (C{LatLon}).

1252

1253 @raise TypeError: The B{C{other}} point is incompatible or

1254 B{C{radius}} is invalid.

1255

1256 @raise ValueError: Invalid B{C{height}} or B{C{fraction}}.

1257 '''

1258 r, D, _ = self._rhumb3(exact, radius)

1259 f = Scalar(fraction=fraction)

1260 d = r._Inverse(self, other, wrap) # C.AZIMUTH_DISTANCE

1261 d = r._Direct( self, d.azi12, d.s12 * f)

1262 h = self._havg(other, f=f, h=height)

1263 return self.classof(d.lat2, d.lon2, datum=D, height=h)

1264

1265 def thomasTo(self, other, wrap=False):

1266 '''Compute the distance between this and an other point using

1267 U{Thomas'<https://apps.DTIC.mil/dtic/tr/fulltext/u2/703541.pdf>}

1268 formula.

1269

1270 @arg other: The other point (C{LatLon}).

1271 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll

1272 the B{C{other}} point (C{bool}).

1273

1274 @return: Distance (C{meter}, same units as the axes of

1275 this point's datum ellipsoid).

1276

1277 @raise TypeError: The B{C{other}} point is not C{LatLon}.

1278

1279 @see: Function L{pygeodesy.thomas} and methods L{cosineAndoyerLambertTo},

1280 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},

1281 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},

1282 L{flatPolarTo}, L{haversineTo} and L{vincentysTo}.

1283 '''

1284 return self._distanceTo_(thomas_, other, wrap=wrap)

1285

1286 @deprecated_method

1287 def to2ab(self): # PYCHOK no cover

1288 '''DEPRECATED, use property L{philam}.'''

1289 return self.philam

1290

1291 def toCartesian(self, height=None, Cartesian=None, **Cartesian_kwds):

1292 '''Convert this point to cartesian, I{geocentric} coordinates,

1293 also known as I{Earth-Centered, Earth-Fixed} (ECEF).

1294

1295 @kwarg height: Optional height, overriding this point's height

1296 (C{meter}, conventionally).

1297 @kwarg Cartesian: Optional class to return the geocentric

1298 coordinates (C{Cartesian}) or C{None}.

1299 @kwarg Cartesian_kwds: Optional, additional B{C{Cartesian}}

1300 keyword arguments, ignored if

1301 C{B{Cartesian} is None}.

1302

1303 @return: A B{C{Cartesian}} or if B{C{Cartesian}} is C{None},

1304 an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M,

1305 datum)} with C{C=0} and C{M} if available.

1306

1307 @raise TypeError: Invalid B{C{Cartesian}} or B{C{Cartesian_kwds}}.

1308 '''

1309 r = self._ecef9 if height is None else self.toEcef(height=height)

1310 if Cartesian is not None: # class or .classof

1311 r = self._xnamed(Cartesian(r, **Cartesian_kwds))

1312 _xdatum(r.datum, self.datum)

1313 return r

1314

1315 def _toCartesianEcef(self, height=None, i=None, up=2, **name_point):

1316 '''(INTERNAL) Convert to cartesian and check Ecef's before and after.

1317 '''

1318 p = self.others(up=up, **name_point)

1319 c = p.toCartesian(height=height)

1320 E = self.Ecef

1321 if E:

1322 for p in (p, c):

1323 e = getattr(p, LatLonBase.Ecef.name, None)

1324 if e not in (None, E): # PYCHOK no cover

1325 n, _ = name_point.popitem()

1326 if i is not None:

1327 Fmt.SQUARE(n, i)

1328 raise _ValueError(n, e, txt=_incompatible(E.__name__))

1329 return c

1330

1331 def toEcef(self, height=None, M=False):

1332 '''Convert this point to I{geocentric} coordinates, also known as

1333 I{Earth-Centered, Earth-Fixed} (U{ECEF<https://WikiPedia.org/wiki/ECEF>}).

1334

1335 @kwarg height: Optional height, overriding this point's height

1336 (C{meter}, conventionally).

1337 @kwarg M: Optionally, include the rotation L{EcefMatrix} (C{bool}).

1338

1339 @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}

1340 with C{C=0} and C{M} if available.

1341

1342 @raise EcefError: A C{.datum} or an ECEF issue.

1343 '''

1344 return self._ecef9 if height in (None, self.height) else \

1345 self._Ecef_forward(self.lat, self.lon, height=height, M=M)

1346

1347 @deprecated_method

1348 def to3llh(self, height=None): # PYCHOK no cover

1349 '''DEPRECATED, use property L{latlonheight} or C{latlon.to3Tuple(B{height})}.'''

1350 return self.latlonheight if height in (None, self.height) else \

1351 self.latlon.to3Tuple(height)

1352

1353 def toLocal(self, Xyz=None, ltp=None, **Xyz_kwds):

1354 '''Convert this I{geodetic} point to I{local} C{X}, C{Y} and C{Z}.

1355

1356 @kwarg Xyz: Optional class to return C{X}, C{Y} and C{Z}

1357 (L{XyzLocal}, L{Enu}, L{Ned}) or C{None}.

1358 @kwarg ltp: The I{local tangent plane} (LTP) to use,

1359 overriding this point's LTP (L{Ltp}).

1360 @kwarg Xyz_kwds: Optional, additional B{C{Xyz}} keyword

1361 arguments, ignored if C{B{Xyz} is None}.

1362

1363 @return: An B{C{Xyz}} instance or if C{B{Xyz} is None},

1364 a L{Local9Tuple}C{(x, y, z, lat, lon, height,

1365 ltp, ecef, M)} with C{M=None}, always.

1366

1367 @raise TypeError: Invalid B{C{ltp}}.

1368 '''

1369 p = _MODS.ltp._xLtp(ltp, self._ltp)

1370 return p._ecef2local(self._ecef9, Xyz, Xyz_kwds)

1371

1372 def toLtp(self, Ecef=None):

1373 '''Return the I{local tangent plane} (LTP) for this point.

1374

1375 @kwarg Ecef: Optional ECEF I{class} (L{EcefKarney}, ...

1376 L{EcefYou}), overriding this point's C{Ecef}.

1377 '''

1378 return self._ltp if Ecef in (None, self.Ecef) else _MODS.ltp.Ltp(

1379 self, ecef=Ecef(self.datum), name=self.name)

1380

1381 def toNormal(self, deep=False, name=NN):

1382 '''Get this point I{normalized} to C{abs(lat) <= 90}

1383 and C{abs(lon) <= 180}.

1384

1385 @kwarg deep: If C{True} make a deep, otherwise a

1386 shallow copy (C{bool}).

1387 @kwarg name: Optional name of the copy (C{str}).

1388

1389 @return: A copy of this point, I{normalized} and

1390 optionally renamed (C{LatLon}).

1391

1392 @see: Property L{isnormal}, method L{normal} and function

1393 L{pygeodesy.normal}.

1394 '''

1395 ll = self.copy(deep=deep)

1396 _ = ll.normal()

1397 if name:

1398 ll.rename(name)

1399 return ll

1400

1401 def toNvector(self, h=None, Nvector=None, **Nvector_kwds):

1402 '''Convert this point to C{n-vector} (normal to the earth's surface)

1403 components, I{including height}.

1404

1405 @kwarg h: Optional height, overriding this point's

1406 height (C{meter}).

1407 @kwarg Nvector: Optional class to return the C{n-vector}

1408 components (C{Nvector}) or C{None}.

1409 @kwarg Nvector_kwds_wrap: Optional, additional B{C{Nvector}}

1410 keyword arguments, ignored if C{B{Nvector}

1411 is None}.

1412

1413 @return: A B{C{Nvector}} or a L{Vector4Tuple}C{(x, y, z, h)}

1414 if B{C{Nvector}} is C{None}.

1415

1416 @raise TypeError: Invalid B{C{Nvector}} or B{C{Nvector_kwds}}.

1417 '''

1418 return self.toVector(Vector=Nvector, h=self.height if h is None else h,

1419 ll=self, **Nvector_kwds)

1420

1421 def toStr(self, form=F_DMS, joined=_COMMASPACE_, m=_m_, **prec_sep_s_D_M_S): # PYCHOK expected

1422 '''Convert this point to a "lat, lon[, +/-height]" string, formatted

1423 in the given C{B{form}at}.

1424

1425 @kwarg form: The lat-/longitude C{B{form}at} to use (C{str}), see

1426 functions L{pygeodesy.latDMS} or L{pygeodesy.lonDMS}.

1427 @kwarg joined: Separator to join the lat-, longitude and heigth

1428 strings (C{str} or C{None} or C{NN} for non-joined).

1429 @kwarg m: Optional unit of the height (C{str}), use C{None} to

1430 exclude height from the returned string.

1431 @kwarg prec_sep_s_D_M_S: Optional C{B{prec}ision}, C{B{sep}arator},

1432 B{C{s_D}}, B{C{s_M}}, B{C{s_S}} and B{C{s_DMS}} keyword

1433 arguments, see function L{pygeodesy.latDMS} or

1434 L{pygeodesy.lonDMS}.

1435

1436 @return: This point in the specified C{B{form}at}, etc. (C{str} or

1437 a 2- or 3-tuple C{(lat_str, lon_str[, height_str])} if

1438 C{B{joined}=NN} or C{B{joined}=None}).

1439

1440 @see: Function L{pygeodesy.latDMS} or L{pygeodesy.lonDMS} for more

1441 details about keyword arguments C{B{form}at}, C{B{prec}ision},

1442 C{B{sep}arator}, B{C{s_D}}, B{C{s_M}}, B{C{s_S}} and B{C{s_DMS}}.

1443

1444 @example:

1445

1446 >>> LatLon(51.4778, -0.0016).toStr() # 51°28′40″N, 000°00′06″W

1447 >>> LatLon(51.4778, -0.0016).toStr(F_D) # 51.4778°N, 000.0016°W

1448 >>> LatLon(51.4778, -0.0016, 42).toStr() # 51°28′40″N, 000°00′06″W, +42.00m

1449 '''

1450 t = (latDMS(self.lat, form=form, **prec_sep_s_D_M_S),

1451 lonDMS(self.lon, form=form, **prec_sep_s_D_M_S))

1452 if self.height and m is not None:

1453 t += (self.heightStr(m=m),)

1454 return joined.join(t) if joined else t

1455

1456 def toVector(self, Vector=None, **Vector_kwds):

1457 '''Convert this point to C{n-vector} (normal to the earth's

1458 surface) components, I{ignoring height}.

1459

1460 @kwarg Vector: Optional class to return the C{n-vector}

1461 components (L{Vector3d}) or C{None}.

1462 @kwarg Vector_kwds: Optional, additional B{C{Vector}}

1463 keyword arguments, ignored if

1464 C{B{Vector} is None}.

1465

1466 @return: A B{C{Vector}} or a L{Vector3Tuple}C{(x, y, z)}

1467 if B{C{Vector}} is C{None}.

1468

1469 @raise TypeError: Invalid B{C{Vector}} or B{C{kwds}}.

1470

1471 @note: These are C{n-vector} x, y and z components,

1472 I{NOT} geocentric (ECEF) x, y and z coordinates!

1473 '''

1474 r = self._vector3tuple

1475 if Vector is not None:

1476 r = Vector(*r, **_xkwds(Vector_kwds, name=self.name))

1477 return r

1478

1479 def toVector3d(self):

1480 '''Convert this point to C{n-vector} (normal to the earth's

1481 surface) components, I{ignoring height}.

1482

1483 @return: Unit vector (L{Vector3d}).

1484

1485 @note: These are C{n-vector} x, y and z components,

1486 I{NOT} geocentric (ECEF) x, y and z coordinates!

1487 '''

1488 return self._vector3d # XXX .unit()

1489

1490 def toWm(self, **toWm_kwds):

1491 '''Convert this point to a WM coordinate.

1492

1493 @kwarg toWm_kwds: Optional L{pygeodesy.toWm} keyword arguments.

1494

1495 @return: The WM coordinate (L{Wm}).

1496

1497 @see: Function L{pygeodesy.toWm}.

1498 '''

1499 return self._wm if not toWm_kwds else _MODS.webmercator.toWm(

1500 self, **_xkwds(toWm_kwds, name=self.name))

1501

1502 @deprecated_method

1503 def to3xyz(self): # PYCHOK no cover

1504 '''DEPRECATED, use property L{xyz} or method L{toNvector}, L{toVector},

1505 L{toVector3d} or perhaps (geocentric) L{toEcef}.'''

1506 return self.xyz # self.toVector()

1507

1508 @Property_RO

1509 def _vector3d(self):

1510 '''(INTERNAL) Cache for L{toVector3d}.

1511 '''

1512 return self.toVector(Vector=Vector3d) # XXX .unit()

1513

1514 @Property_RO

1515 def _vector3tuple(self):

1516 '''(INTERNAL) Cache for L{toVector}.

1517 '''

1518 return philam2n_xyz(self.phi, self.lam, name=self.name)

1519

1520 def vincentysTo(self, other, **radius_wrap):

1521 '''Compute the distance between this and an other point using

1522 U{Vincenty's<https://WikiPedia.org/wiki/Great-circle_distance>}

1523 spherical formula.

1524

1525 @arg other: The other point (C{LatLon}).

1526 @kwarg radius_wrap: Optional keyword arguments for function

1527 L{pygeodesy.vincentys}, overriding the

1528 default mean C{radius} of this point's

1529 datum ellipsoid.

1530

1531 @return: Distance (C{meter}, same units as B{C{radius}}).

1532

1533 @raise TypeError: The B{C{other}} point is not C{LatLon}.

1534

1535 @see: Function L{pygeodesy.vincentys} and methods L{cosineAndoyerLambertTo},

1536 L{cosineForsytheAndoyerLambertTo}, L{cosineLawTo}, C{distanceTo*},

1537 L{equirectangularTo}, L{euclideanTo}, L{flatLocalTo}/L{hubenyTo},

1538 L{flatPolarTo}, L{haversineTo} and L{thomasTo}.

1539 '''

1540 return self._distanceTo(vincentys, other, **_xkwds(radius_wrap, radius=None))

1541

1542 @Property_RO

1543 def _wm(self):

1544 '''(INTERNAL) Get this point as webmercator (L{Wm}).

1545 '''

1546 return _MODS.webmercator.toWm(self)

1547

1548 @Property_RO

1549 def xyz(self):

1550 '''Get the C{n-vector} X, Y and Z components (L{Vector3Tuple}C{(x, y, z)})

1551

1552 @note: These are C{n-vector} x, y and z components, I{NOT}

1553 geocentric (ECEF) x, y and z coordinates!

1554 '''

1555 return self.toVector(Vector=Vector3Tuple)

1556

1557 @Property_RO

1558 def xyzh(self):

1559 '''Get the C{n-vector} X, Y, Z and H components (L{Vector4Tuple}C{(x, y, z, h)})

1560

1561 @note: These are C{n-vector} x, y and z components, I{NOT}

1562 geocentric (ECEF) x, y and z coordinates!

1563 '''

1564 return self.xyz.to4Tuple(self.height)

1565

1566

1567 class _toCartesian3(object): # see also .geodesicw._wargs, .vector2d._numpy

1568 '''(INTERNAL) Wrapper to convert 2 other points.

1569 '''

1570 @contextmanager # <https://www.python.org/dev/peps/pep-0343/> Examples

1571 def __call__(self, p, p2, p3, wrap, **kwds):

1572 try:

1573 if wrap:

1574 p2, p3 = map1(_Wrap.point, p2, p3)

1575 kwds = _xkwds(kwds, wrap=wrap)

1576 yield (p. toCartesian().copy(name=_point_), # copy to rename

1577 p._toCartesianEcef(up=4, point2=p2),

1578 p._toCartesianEcef(up=4, point3=p3))

1579 except (AssertionError, TypeError, ValueError) as x:

1580 raise _xError(x, point=p, point2=p2, point3=p3, **kwds)

1581

1582_toCartesian3 = _toCartesian3() # PYCHOK singleton

1583

1584

1585 def _trilaterate5(p1, d1, p2, d2, p3, d3, area=True, eps=EPS1, # MCCABE 13

1586 radius=R_M, wrap=False):

1587 '''(INTERNAL) Trilaterate three points by I{area overlap} or by

1588 I{perimeter intersection} of three circles.

1589

1590 @note: The B{C{radius}} is only needed for both the n-vectorial

1591 and C{sphericalTrigonometry.LatLon.distanceTo} methods and

1592 silently ignored by the C{ellipsoidalExact}, C{-GeodSolve},

1593 C{-Karney} and C{-Vincenty.LatLon.distanceTo} methods.

1594 '''

1595 p2, p3, w = _unrollon3(p1, p2, p3, wrap)

1596

1597 r1 = Distance_(distance1=d1)

1598 r2 = Distance_(distance2=d2)

1599 r3 = Distance_(distance3=d3)

1600 m = 0 if area else (r1 + r2 + r3)

1601 pc = 0

1602 t = []

1603 for _ in range(3):

1604 try: # intersection of circle (p1, r1) and (p2, r2)

1605 c1, c2 = p1.intersections2(r1, p2, r2, wrap=w)

1606

1607 if area: # check overlap

1608 if c1 is c2: # abutting

1609 c = c1

1610 else: # nearest point on radical

1611 c = p3.nearestOn(c1, c2, within=True, wrap=w)

1612 d = r3 - p3.distanceTo(c, radius=radius, wrap=w)

1613 if d > eps: # sufficient overlap

1614 t.append((d, c))

1615 m = max(m, d)

1616

1617 else: # check intersection

1618 for c in ((c1,) if c1 is c2 else (c1, c2)):

1619 d = fabs(r3 - p3.distanceTo(c, radius=radius, wrap=w))

1620 if d < eps: # below margin

1621 t.append((d, c))

1622 m = min(m, d)

1623

1624 except IntersectionError as x:

1625 if _concentric_ in str(x): # XXX ConcentricError?

1626 pc += 1

1627

1628 p1, r1, p2, r2, p3, r3 = p2, r2, p3, r3, p1, r1 # rotate

1629

1630 if t: # get min, max, points and count ...

1631 t = tuple(sorted(t))

1632 n = len(t), # as 1-tuple

1633 # ... or for a single trilaterated result,

1634 # min *is* max, min- *is* maxPoint and n=1, 2 or 3

1635 return Trilaterate5Tuple(t[0] + t[-1] + n) # *(t[0] + ...)

1636

1637 elif area and pc == 3: # all pairwise concentric ...

1638 r, p = min((r1, p1), (r2, p2), (r3, p3))

1639 m = max(r1, r2, r3)

1640 # ... return "smallest" point twice, the smallest

1641 # and largest distance and n=0 for concentric

1642 return Trilaterate5Tuple(float(r), p, float(m), p, 0)

1643

1644 n, f = (_overlap_, max) if area else (_intersection_, min)

1645 t = _COMMASPACE_(_no_(n), '%s %.3g' % (f.__name__, m))

1646 raise IntersectionError(area=area, eps=eps, wrap=wrap, txt=t)

1647

1648

1649__all__ += _ALL_DOCS(LatLonBase)

1650

1651# **) MIT License

1652#

1653# Copyright (C) 2016-2023 -- mrJean1 at Gmail -- All Rights Reserved.

1654#

1655# Permission is hereby granted, free of charge, to any person obtaining a

1656# copy of this software and associated documentation files (the "Software"),

1657# to deal in the Software without restriction, including without limitation

1658# the rights to use, copy, modify, merge, publish, distribute, sublicense,

1659# and/or sell copies of the Software, and to permit persons to whom the

1660# Software is furnished to do so, subject to the following conditions:

1661#

1662# The above copyright notice and this permission notice shall be included

1663# in all copies or substantial portions of the Software.

1664#

1665# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

1666# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

1667# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

1668# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR

1669# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

1670# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

1671# OTHER DEALINGS IN THE SOFTWARE.