Coverage for pygeodesy/ellipsoidalGeodSolve.py: 100%

1

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

3

4 u'''Exact ellipsoidal geodesy, intended I{for testing purposes only}.

5

6 Ellipsoidal geodetic (lat-/longitude) L{LatLon} and geocentric

7(ECEF) L{Cartesian} classes and functions L{areaOf}, L{intersections2},

8 L{isclockwise}, L{nearestOn} and L{perimeterOf} based on module

9 L{geodsolve}, a wrapper invoking I{Karney}'s U{GeodSolve

10<https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>} utility.

11'''

12

13# from pygeodesy.datums import _WGS84 # from .ellipsoidalBase

14 from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase, \

15 _nearestOn, Property_RO, _WGS84

16 from pygeodesy.ellipsoidalBaseDI import LatLonEllipsoidalBaseDI, _TOL_M, \

17 _intersection3, _intersections2

18# from pygeodesy.errors import _xkwds # from .karney

19 from pygeodesy.karney import fabs, _polygon, _xkwds

20 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _ALL_OTHER

21 from pygeodesy.points import _areaError, ispolar # PYCHOK exported

22# from pygeodesy.props import Property_RO # from .karney

23

24# from math import fabs # from .karney

25

26 __all__ = _ALL_LAZY.ellipsoidalGeodSolve

27 __version__ = '25.08.28'

28

29

30 class Cartesian(CartesianEllipsoidalBase):

31 '''Extended to convert exact L{Cartesian} to exact L{LatLon} points.

32 '''

33

34 def toLatLon(self, **LatLon_and_kwds): # PYCHOK LatLon=LatLon, datum=None

35 '''Convert this cartesian point to an exact geodetic point.

36

37 @kwarg LatLon_and_kwds: Optional L{LatLon} and L{LatLon} keyword

38 arguments as C{datum}. Use C{B{LatLon}=...,

39 B{datum}=...} to override this L{LatLon}

40 class or specify C{B{LatLon}=None}.

41

42 @return: The geodetic point (L{LatLon}) or if C{B{LatLon} is None},

43 an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}

44 with C{C} and C{M} if available.

45

46 @raise TypeError: Invalid B{C{LatLon_and_kwds}} argument.

47 '''

48 kwds = _xkwds(LatLon_and_kwds, LatLon=LatLon, datum=self.datum)

49 return CartesianEllipsoidalBase.toLatLon(self, **kwds)

50

51

52 class LatLon(LatLonEllipsoidalBaseDI):

53 '''An ellipsoidal L{LatLon} like L{ellipsoidalKarney.LatLon} but using (exact)

54 geodesic I{wrapper} L{GeodesicSolve} to compute the geodesic distance,

55 initial and final bearing (azimuths) between two given points or the

56 destination point given a start point and an (initial) bearing.

57 '''

58

59 @Property_RO

60 def Equidistant(self):

61 '''Get the prefered azimuthal equidistant projection I{class} (L{EquidistantGeodSolve}).

62 '''

63 return _MODS.azimuthal.EquidistantGeodSolve

64

65 @Property_RO

66 def geodesicx(self):

67 '''Get this C{LatLon}'s (exact) geodesic (L{GeodesicSolve}).

68 '''

69 return self.datum.ellipsoid.geodsolve

70

71 geodesic = geodesicx # for C{._Direct} and C{._Inverse}

72

73 def toCartesian(self, **Cartesian_datum_kwds): # PYCHOK Cartesian=Cartesian, datum=None

74 '''Convert this point to exact cartesian (ECEF) coordinates.

75

76 @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}} and other keyword

77 arguments, ignored if C{B{Cartesian} is None}. Use C{B{Cartesian}=Class}

78 to override this L{Cartesian} class or set C{B{Cartesian}=None}.

79

80 @return: The cartesian (ECEF) coordinates (L{Cartesian}) or if C{B{Cartesian} is

81 None}, an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with

82 C{C} and C{M} if available.

83

84 @raise TypeError: Invalid B{C{Cartesian}}, B{C{datum}} or other B{C{Cartesian_datum_kwds}}.

85 '''

86 kwds = _xkwds(Cartesian_datum_kwds, Cartesian=Cartesian, datum=self.datum)

87 return LatLonEllipsoidalBaseDI.toCartesian(self, **kwds)

88

89

90 def areaOf(points, datum=_WGS84, wrap=True, polar=False):

91 '''Compute the area of an (ellipsoidal) polygon or composite.

92

93 @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).

94 @kwarg datum: Optional datum (L{Datum}).

95 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).

96 @kwarg polar: Use C{B{polar}=True} if the polygon encloses a pole (C{bool}), see

97 function L{ispolar<pygeodesy.points.ispolar>} and U{area of a polygon

98 enclosing a pole<https://GeographicLib.SourceForge.io/C++/doc/

99 classGeographicLib_1_1GeodesicExact.html#a3d7a9155e838a09a48dc14d0c3fac525>}.

100

101 @return: Area (C{meter}, same as units of the B{C{datum}}'s ellipsoid axes, I{squared}).

102

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

104

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

106

107 @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled longitudes not supported.

108

109 @see: Functions L{pygeodesy.areaOf}, L{ellipsoidalExact.areaOf}, L{ellipsoidalKarney.areaOf},

110 L{sphericalNvector.areaOf} and L{sphericalTrigonometry.areaOf}.

111 '''

112 return fabs(_polygon(datum.ellipsoid.geodsolve, points, True, False, wrap, polar))

113

114

115 def intersection3(start1, end1, start2, end2, height=None, wrap=False, # was=True

116 equidistant=None, tol=_TOL_M, LatLon=LatLon, **LatLon_kwds):

117 '''I{Iteratively} compute the intersection point of two lines, each defined

118 by two (ellipsoidal) points or by an (ellipsoidal) start point and an

119 (initial) bearing from North.

120

121 @arg start1: Start point of the first line (L{LatLon}).

122 @arg end1: End point of the first line (L{LatLon}) or the initial bearing

123 at the first point (compass C{degrees360}).

124 @arg start2: Start point of the second line (L{LatLon}).

125 @arg end2: End point of the second line (L{LatLon}) or the initial bearing

126 at the second point (compass C{degrees360}).

127 @kwarg height: Optional height at the intersection (C{meter}, conventionally)

128 or C{None} for the mean height.

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

130 and B{C{end*}} points (C{bool}).

131 @kwarg equidistant: An azimuthal equidistant projection (I{class} or function

132 L{pygeodesy.equidistant}) or C{None} for the preferred

133 C{B{start1}.Equidistant}.

134 @kwarg tol: Tolerance for convergence and for skew line distance and length

135 (C{meter}, conventionally).

136 @kwarg LatLon: Optional class to return the intersection points (L{LatLon})

137 or C{None}.

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

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

140

141 @return: An L{Intersection3Tuple}C{(point, outside1, outside2)} with C{point}

142 a B{C{LatLon}} or if C{B{LatLon} is None}, a L{LatLon4Tuple}C{(lat,

143 lon, height, datum)}.

144

145 @raise IntersectionError: Skew, colinear, parallel or otherwise

146 non-intersecting lines or no convergence

147 for the given B{C{tol}}.

148

149 @raise TypeError: Invalid or non-ellipsoidal B{C{start1}}, B{C{end1}},

150 B{C{start2}} or B{C{end2}} or invalid B{C{equidistant}}.

151

152 @note: For each line specified with an initial bearing, a pseudo-end point

153 is computed as the C{destination} along that bearing at about 1.5

154 times the distance from the start point to an initial gu-/estimate

155 of the intersection point (and between 1/8 and 3/8 of the authalic

156 earth perimeter).

157

158 @see: U{The B{ellipsoidal} case<https://GIS.StackExchange.com/questions/48937/

159 calculating-intersection-of-two-circles>} and U{Karney's paper

160 <https://ArXiv.org/pdf/1102.1215.pdf>}, pp 20-21, section B{14. MARITIME

161 BOUNDARIES} for more details about the iteration algorithm.

162 '''

163 return _intersection3(start1, end1, start2, end2, height=height, wrap=wrap,

164 equidistant=equidistant, tol=tol, LatLon=LatLon, **LatLon_kwds)

165

166

167 def intersections2(center1, radius1, center2, radius2, height=None, wrap=False, # was=True

168 equidistant=None, tol=_TOL_M, LatLon=LatLon, **LatLon_kwds):

169 '''I{Iteratively} compute the intersection points of two circles, each defined

170 by an (ellipsoidal) center point and a radius.

171

172 @arg center1: Center of the first circle (L{LatLon}).

173 @arg radius1: Radius of the first circle (C{meter}, conventionally).

174 @arg center2: Center of the second circle (L{LatLon}).

175 @arg radius2: Radius of the second circle (C{meter}, same units as

176 B{C{radius1}}).

177 @kwarg height: Optional height for the intersection points (C{meter},

178 conventionally) or C{None} for the I{"radical height"}

179 at the I{radical line} between both centers.

180 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{center2}}

181 (C{bool}).

182 @kwarg equidistant: An azimuthal equidistant projection (I{class} or

183 function L{pygeodesy.equidistant}) or C{None} for

184 the preferred C{B{center1}.Equidistant}.

185 @kwarg tol: Convergence tolerance (C{meter}, same units as B{C{radius1}}

186 and B{C{radius2}}).

187 @kwarg LatLon: Optional class to return the intersection points (L{LatLon})

188 or C{None}.

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

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

191

192 @return: 2-Tuple of the intersection points, each a B{C{LatLon}} instance

193 or L{LatLon4Tuple}C{(lat, lon, height, datum)} if C{B{LatLon} is

194 None}. For abutting circles, both points are the same instance,

195 aka the I{radical center}.

196

197 @raise IntersectionError: Concentric, antipodal, invalid or non-intersecting

198 circles or no convergence for the B{C{tol}}.

199

200 @raise TypeError: Invalid or non-ellipsoidal B{C{center1}} or B{C{center2}}

201 or invalid B{C{equidistant}}.

202

203 @raise UnitError: Invalid B{C{radius1}}, B{C{radius2}} or B{C{height}}.

204

205 @see: U{The B{ellipsoidal} case<https://GIS.StackExchange.com/questions/48937/

206 calculating-intersection-of-two-circles>}, U{Karney's paper

207 <https://ArXiv.org/pdf/1102.1215.pdf>}, pp 20-21, section B{14. MARITIME BOUNDARIES},

208 U{Circle-Circle<https://MathWorld.Wolfram.com/Circle-CircleIntersection.html>} and

209 U{Sphere-Sphere<https://MathWorld.Wolfram.com/Sphere-SphereIntersection.html>}

210 intersections.

211 '''

212 return _intersections2(center1, radius1, center2, radius2, height=height, wrap=wrap,

213 equidistant=equidistant, tol=tol, LatLon=LatLon, **LatLon_kwds)

214

215

216 def isclockwise(points, datum=_WGS84, wrap=True, polar=False):

217 '''Determine the direction of a path or polygon.

218

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

220 @kwarg datum: Optional datum (L{Datum}).

221 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).

222 @kwarg polar: Use C{B{polar}=True} if the C{B{points}} enclose a pole (C{bool}),

223 see function U{ispolar<pygeodeys.points.ispolar>}.

224

225 @return: C{True} if B{C{points}} are clockwise, C{False} otherwise.

226

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

228

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

230

231 @raise ValueError: The B{C{points}} enclose a pole or zero area.

232

233 @see: L{pygeodesy.isclockwise}.

234 '''

235 a = _polygon(datum.ellipsoid.geodsolve, points, True, False, wrap, polar)

236 if a < 0:

237 return True

238 elif a > 0:

239 return False

240 raise _areaError(points)

241

242

243 def nearestOn(point, point1, point2, within=True, height=None, wrap=False,

244 equidistant=None, tol=_TOL_M, LatLon=LatLon, **LatLon_kwds):

245 '''I{Iteratively} locate the closest point on the geodesic between

246 two other (ellipsoidal) points.

247

248 @arg point: Reference point (C{LatLon}).

249 @arg point1: Start point of the geodesic (C{LatLon}).

250 @arg point2: End point of the geodesic (C{LatLon}).

251 @kwarg within: If C{True}, return the closest point I{between}

252 B{C{point1}} and B{C{point2}}, otherwise the

253 closest point elsewhere on the geodesic (C{bool}).

254 @kwarg height: Optional height for the closest point (C{meter},

255 conventionally) or C{None} or C{False} for the

256 interpolated height. If C{False}, the closest

257 takes the heights of the points into account.

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

259 B{C{point1}} and B{C{point2}} (C{bool}).

260 @kwarg equidistant: An azimuthal equidistant projection (I{class}

261 or function L{pygeodesy.equidistant}) or C{None}

262 for the preferred C{B{point}.Equidistant}.

263 @kwarg tol: Convergence tolerance (C{meter}).

264 @kwarg LatLon: Optional class to return the closest point

265 (L{LatLon}) or C{None}.

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

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

268

269 @return: Closest point, a B{C{LatLon}} instance or if C{B{LatLon}

270 is None}, a L{LatLon4Tuple}C{(lat, lon, height, datum)}.

271

272 @raise TypeError: Invalid or non-ellipsoidal B{C{point}}, B{C{point1}}

273 or B{C{point2}} or invalid B{C{equidistant}}.

274

275 @raise ValueError: No convergence for the B{C{tol}}.

276

277 @see: U{The B{ellipsoidal} case<https://GIS.StackExchange.com/questions/48937/

278 calculating-intersection-of-two-circles>} and U{Karney's paper

279 <https://ArXiv.org/pdf/1102.1215.pdf>}, pp 20-21, section B{14. MARITIME

280 BOUNDARIES} for more details about the iteration algorithm.

281 '''

282 return _nearestOn(point, point1, point2, within=within, height=height, wrap=wrap,

283 equidistant=equidistant, tol=tol, LatLon=LatLon, **LatLon_kwds)

284

285

286 def perimeterOf(points, closed=False, datum=_WGS84, wrap=True):

287 '''Compute the perimeter of an (ellipsoidal) polygon or composite.

288

289 @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).

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

291 @kwarg datum: Optional datum (L{Datum}).

292 @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).

293

294 @return: Perimeter (C{meter}, same as units of the B{C{datum}}'s ellipsoid axes).

295

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

297

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

299

300 @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled longitudes not

301 supported or C{B{closed}=False} with C{B{points}} a composite.

302

303 @see: Functions L{pygeodesy.perimeterOf}, L{ellipsoidalExact.perimeterOf},

304 L{ellipsoidalKarney.perimeterOf}, L{sphericalNvector.perimeterOf}

305 and L{sphericalTrigonometry.perimeterOf}.

306 '''

307 return _polygon(datum.ellipsoid.geodsolve, points, closed, True, wrap, False)

308

309

310 __all__ += _ALL_OTHER(Cartesian, LatLon, # classes

311 areaOf, # functions

312 intersection3, intersections2, isclockwise, ispolar,

313 nearestOn, perimeterOf)

314

315# **) MIT License

316#

317# Copyright (C) 2016-2026 -- mrJean1 at Gmail -- All Rights Reserved.

318#

319# Permission is hereby granted, free of charge, to any person obtaining a

320# copy of this software and associated documentation files (the "Software"),

321# to deal in the Software without restriction, including without limitation

322# the rights to use, copy, modify, merge, publish, distribute, sublicense,

323# and/or sell copies of the Software, and to permit persons to whom the

324# Software is furnished to do so, subject to the following conditions:

325#

326# The above copyright notice and this permission notice shall be included

327# in all copies or substantial portions of the Software.

328#

329# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

330# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

331# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

332# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR

333# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

334# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

335# OTHER DEALINGS IN THE SOFTWARE.