pygeodesy 24.6.24__py2.py3-none-any.whl → 24.7.7__py2.py3-none-any.whl

pygeodesy/geodsolve.py

@@ -10,48 +10,31 @@ of the C{GeodSolve} executable.
 '''
 
 from pygeodesy.basics import _xinstanceof
-# from pygeodesy.constants import NAN, _0_0 # from .karney
+# from pygeodesy.constants import NAN, _0_0  # from .karney
 # from pygeodesy.geodesicx import GeodesicAreaExact  # _MODS
-from pygeodesy.interns import NN, _a12_, _azi1_, _azi2_, \
-                             _lat1_, _lat2_, _lon1_, _lon2_, _m12_, \
-                             _M12_, _M21_, _s12_, _S12_, _UNDER_
-from pygeodesy.interns import _UNUSED_, _not_  # PYCHOK used!
-from pygeodesy.karney import _Azi, Caps, _Deg, GeodesicError, _GTuple, \
-                             _Pass, _Lat, _Lon, _M, _M2, _sincos2d, \
-                             _0_0, NAN
+from pygeodesy.interns import NN, _UNDER_
+from pygeodesy.karney import Caps, GeodesicError, GeodSolve12Tuple, \
+                            _llz2line, _sincos2d,  _0_0, NAN
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, \
                              _getenv, _PYGEODESY_GEODSOLVE_
 from pygeodesy.named import _name1__
 from pygeodesy.namedTuples import Destination3Tuple, Distance3Tuple
 from pygeodesy.props import Property, Property_RO, property_RO
-from pygeodesy.solveBase import _SolveBase, _SolveLineBase
+from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '24.06.26'
+__version__ = '24.07.09'
 
 
-class GeodSolve12Tuple(_GTuple):
-    '''12-Tuple C{(lat1, lon1, azi1, lat2, lon2, azi2, s12, a12, m12, M12, M21, S12)} with
-       angles C{lat1}, C{lon1}, C{azi1}, C{lat2}, C{lon2} and C{azi2} and arc C{a12} all in
-       C{degrees}, initial C{azi1} and final C{azi2} forward azimuths, distance C{s12} and
-       reduced length C{m12} in C{meter}, area C{S12} in C{meter} I{squared} and geodesic
-       scale factors C{M12} and C{M21}, both C{scalar}, see U{GeodSolve
-       <https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>}.
-    '''
-    # from GeodSolve --help option -f ... lat1 lon1 azi1 lat2 lon2 azi2 s12 a12 m12 M12 M21 S12
-    _Names_ = (_lat1_, _lon1_, _azi1_, _lat2_, _lon2_, _azi2_, _s12_, _a12_, _m12_, _M12_, _M21_, _S12_)
-    _Units_ = (_Lat,   _Lon,   _Azi,   _Lat,   _Lon,   _Azi,   _M,    _Deg,  _Pass, _Pass, _Pass, _M2)
-
-
-class _GeodesicSolveBase(_SolveBase):
+class _GeodesicSolveBase(_SolveGDictBase):
     '''(INTERNAL) Base class for L{GeodesicSolve} and L{GeodesicLineSolve}.
     '''
     _Error         =  GeodesicError
     _Names_Direct  = \
     _Names_Inverse =  GeodSolve12Tuple._Names_
-    _Solve_name    = 'GeodSolve'
-    _Solve_path    = _getenv(_PYGEODESY_GEODSOLVE_, _PYGEODESY_GEODSOLVE_)
+    _Xable_name    = 'GeodSolve'
+    _Xable_path    = _getenv(_PYGEODESY_GEODSOLVE_, _PYGEODESY_GEODSOLVE_)
 
     @Property_RO
     def _b_option(self):
@@ -67,16 +50,12 @@ class _GeodesicSolveBase(_SolveBase):
                                          self._p_option +
                                          self._u_option)
 
-    @Property_RO
-    def _E_option(self):
-        return ('-E',) if self.Exact else ()
-
     @Property
     def GeodSolve(self):
         '''Get the U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>}
            executable (C{filename}).
         '''
-        return self._Solve_path
+        return self._Xable_path
 
     @GeodSolve.setter  # PYCHOK setter!
     def GeodSolve(self, path):
@@ -86,20 +65,20 @@ class _GeodesicSolveBase(_SolveBase):
            @raise GeodesicError: Invalid B{C{path}}, B{C{path}} doesn't exist or
                                  isn't the C{GeodSolve} executable.
         '''
-        self._setSolve(path)
+        self._setXable(path)
 
     def toStr(self, **prec_sep):  # PYCHOK signature
         '''Return this C{GeodesicSolve} as string.
 
-           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=', '}
-                      for the C{float} C{prec}ision, number of decimal digits
-                      (0..9) and the C{sep}arator string to join.  Trailing
-                      zero decimals are stripped for B{C{prec}} values of
-                      1 and above, but kept for negative B{C{prec}} values.
+           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=", "}
+                       for the C{float} C{prec}ision, number of decimal digits
+                       (0..9) and the C{sep}arator string to join.  Trailing
+                       zero decimals are stripped for B{C{prec}} values of 1
+                       and above, but kept for negative B{C{prec}} values.
 
            @return: GeodesicSolve items (C{str}).
         '''
-        return _SolveBase._toStr(self, GeodSolve=self.GeodSolve, **prec_sep)
+        return _SolveGDictBase._toStr(self, GeodSolve=self.GeodSolve, **prec_sep)
 
     @Property_RO
     def _u_option(self):
@@ -119,11 +98,11 @@ class GeodesicSolve(_GeodesicSolveBase):
     '''
 
     def Area(self, polyline=False, **name):
-        '''Set up a L{GeodesicAreaExact} to compute area and
-           perimeter of a polygon.
+        '''Set up a L{GeodesicAreaExact} to compute area and perimeter
+           of a polygon.
 
-           @kwarg polyline: If C{True} perimeter only, otherwise
-                            area and perimeter (C{bool}).
+           @kwarg polyline: If C{True} perimeter only, otherwise area
+                            and perimeter (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicAreaExact} instance.
@@ -139,8 +118,8 @@ class GeodesicSolve(_GeodesicSolveBase):
     Polygon = Area  # for C{geographiclib} compatibility
 
     def Direct3(self, lat1, lon1, azi1, s12):  # PYCHOK outmask
-        '''Return the destination lat, lon and reverse azimuth
-           (final bearing) in C{degrees}.
+        '''Return the destination lat, lon and reverse azimuth (final bearing)
+           in C{degrees}.
 
            @return: L{Destination3Tuple}C{(lat, lon, final)}.
         '''
@@ -228,10 +207,10 @@ class GeodesicSolve(_GeodesicSolveBase):
         gl = GeodesicLineSolve(self, lat1, lon1, r.azi1, **_name1__(caps_name, _or_nameof=self))
         gl._a13 = r.a12  # gl.SetArc(r.a12)
         gl._s13 = r.s12  # gl.SetDistance(r.s12)
-        return gl
+        return _llz2line(gl, lat2=lat2, lon2=lon2, azi2=r.azi2)
 
 
-class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
+class GeodesicLineSolve(_GeodesicSolveBase, _SolveGDictLineBase):
     '''Wrapper to invoke I{Karney}'s U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>}
        as an C{Exact} version of I{Karney}'s Python class U{GeodesicLine<https://GeographicLib.SourceForge.io/C++/doc/
        python/code.html#geographiclib.geodesicline.GeodesicLine>}.
@@ -269,7 +248,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
         _xinstanceof(GeodesicSolve, geodesic=geodesic)
         if (caps & Caps.LINE_OFF):  # copy to avoid updates
             geodesic = geodesic.copy(deep=False, name=_UNDER_(NN, geodesic.name))  # NOT _under!
-        _SolveLineBase.__init__(self, geodesic, lat1, lon1, caps, azi1=azi1, **name)
+        _SolveGDictLineBase.__init__(self, geodesic, lat1, lon1, caps, azi1=azi1, **name)
         try:
             self.GeodSolve = geodesic.GeodSolve  # geodesic or copy of geodesic
         except GeodesicError:
@@ -299,7 +278,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
            @return: A C{GDict} with 12 items C{lat1, lon1, azi1, lat2, lon2,
                     azi2, m12, a12, s12, M12, M21, S12}.
         '''
-        return self._GDictInvoke(self._cmdArc, True, self._Names_Direct, a12)._unCaps(outmask)
+        return self._GDictInvoke(self._cmdArc, self._Names_Direct, a12)._unCaps(outmask)
 
     @Property_RO
     def azi1(self):
@@ -350,7 +329,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
            @return: A C{GDict} with 12 items C{lat1, lon1, azi1, lat2, lon2,
                     azi2, m12, a12, s12, M12, M21, S12}, possibly C{a12=NAN}.
         '''
-        return self._GDictInvoke(self._cmdDistance, True, self._Names_Direct, s12)._unCaps(outmask)
+        return self._GDictInvoke(self._cmdDistance, self._Names_Direct, s12)._unCaps(outmask)
 
     @Property_RO
     def s13(self):
@@ -392,16 +371,16 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
     def toStr(self, **prec_sep):  # PYCHOK signature
         '''Return this C{GeodesicLineSolve} as string.
 
-           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=', '}
-                      for the C{float} C{prec}ision, number of decimal digits
-                      (0..9) and the C{sep}arator string to join.  Trailing
-                      zero decimals are stripped for B{C{prec}} values of
-                      1 and above, but kept for negative B{C{prec}} values.
+           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=", "}
+                       for the C{float} C{prec}ision, number of decimal digits
+                       (0..9) and the C{sep}arator string to join.  Trailing
+                       zero decimals are stripped for B{C{prec}} values of 1
+                       and above, but kept for negative B{C{prec}} values.
 
            @return: GeodesicLineSolve items (C{str}).
         '''
-        return _SolveLineBase._toStr(self, azi1=self.azi1, geodesic=self._solve,
-                                           GeodSolve=self.GeodSolve, **prec_sep)
+        return _SolveGDictLineBase._toStr(self, azi1=self.azi1, geodesic=self._solve,
+                                                GeodSolve=self.GeodSolve, **prec_sep)
 
 
 __all__ += _ALL_DOCS(_GeodesicSolveBase)
@@ -415,7 +394,7 @@ if __name__ == '__main__':
     gS.verbose = '--verbose' in argv  # or '-v' in argv
 
     if gS.GeodSolve in (_PYGEODESY_GEODSOLVE_, None):  # not set
-        gS.GeodSolve = '/opt/local/bin/GeodSolve'  # '/opt/local/Cellar/geographiclib/1.51/bin/GeodSolve'  # HomeBrew
+        gS.GeodSolve = '/opt/local/bin/GeodSolve'  # '/opt/local/Cellar/geographiclib/2.3/bin/GeodSolve'  # HomeBrew
     printf('version: %s', gS.version)
 
     r = gS.Direct(40.6, -73.8, 51, 5.5e6)

pygeodesy/internals.py

@@ -4,9 +4,9 @@ u'''Mostly INTERNAL functions, except L{machine}, L{print_} and L{printf}.
 '''
 # from pygeodesy.basics import isiterablen  # _MODS
 # from pygeodesy.errors import _AttributeError, _error_init, _UnexpectedError, _xError2  # _MODS
-from pygeodesy.interns import NN, _COLON_, _DOT_, _ELLIPSIS_, _EQUALSPACED_, \
-                             _immutable_, _NL_, _pygeodesy_, _PyPy__, _python_, \
-                             _QUOTE1_, _QUOTE2_, _s_, _SPACE_, _sys, _UNDER_, _utf_8_
+from pygeodesy.interns import NN, _BAR_, _COLON_, _DASH_, _DOT_, _ELLIPSIS_, _EQUALSPACED_, \
+                             _immutable_, _NL_, _pygeodesy_, _PyPy__, _python_, _QUOTE1_, \
+                             _QUOTE2_, _s_, _SPACE_, _sys, _UNDER_, _utf_8_
 from pygeodesy.interns import _COMMA_, _Python_  # PYCHOK used!
 # from pygeodesy.streprs import anstr, pairs, unstr  # _MODS
 
@@ -360,10 +360,10 @@ def _passargs(*args):
     return args
 
 
-def _plural(noun, n):
+def _plural(noun, n, nn=NN):
     '''(INTERNAL) Return C{noun}['s'] or C{NN}.
     '''
-    return NN(noun, _s_) if n > 1 else (noun if n else NN)
+    return NN(noun, _s_) if n > 1 else (noun if n else nn)
 
 
 def print_(*args, **nl_nt_prec_prefix__end_file_flush_sep__kwds):  # PYCHOK no cover
@@ -504,17 +504,44 @@ def _under(name):  # PYCHOK in .datums, .auxilats, .ups, .utm, .utmupsBase, ...
     return name if name.startswith(_UNDER_) else NN(_UNDER_, name)
 
 
-def _usage(file_py, *args):  # in .etm
+def _usage(file_py, *args, **opts_help):  # in .etm, .geodesici
     '''(INTERNAL) Build "usage: python -m ..." cmd line for module B{C{file_py}}.
     '''
-    m = _os_path.dirname(file_py).replace(_os.getcwd(), _ELLIPSIS_) \
-                                 .replace(_os.sep, _DOT_).strip()
-    b, x = _os_path.splitext(_os_path.basename(file_py))
+    if opts_help:
+
+        def _help(alts=(), help=NN, **unused):
+            if alts and help:
+                h = NN(help, _SPACE_).lstrip(_DASH_)
+                for a in alts:
+                    if a.startswith(h):
+                        return NN(_DASH_, a),
+
+        def _opts(opts=NN, alts=(), **unused):
+            # opts='T--v-C-R meter-c|i|n|o'
+            d, fmt = NN, _MODS.streprs.Fmt.SQUARE
+            for o in (opts + _BAR_(*alts)).split(_DASH_):
+                if o:
+                    yield fmt(NN(d, _DASH_, o.replace(_BAR_, ' | -')))
+                    d =  NN
+                else:
+                    d = _DASH_
+
+        args = _help(**opts_help) or (tuple(_opts(**opts_help)) + args)
+
+    u = _COLON_(_dunder_nameof(_usage)[1:], NN)
+    return _SPACE_(u, *_usage_argv(file_py, *args))
+
+
+def _usage_argv(argv0, *args):
+    '''(INTERNAL) Return 3-tuple C{(python, '-m', module, *args)}.
+    '''
+    m = _os_path.dirname(argv0).replace(_os.getcwd(), _ELLIPSIS_) \
+                               .replace(_os.sep, _DOT_).strip()
+    b, x = _os_path.splitext(_os_path.basename(argv0))
     if x == '.py' and not _dunder_ismain(b):
         m = _DOT_(m or _pygeodesy_, b)
-    p =  NN(_python_, _sys.version_info[0])
-    u = _COLON_(_dunder_nameof(_usage)[1:], NN)
-    return _SPACE_(u, p, '-m', _enquote(m), *args)
+    p = NN(_python_, _sys.version_info[0])
+    return (p, '-m', _enquote(m)) + args
 
 
 def _version2(version, n=2):
@@ -550,7 +577,7 @@ def _version_ints(vs):
 
 
 __all__ = tuple(map(_dunder_nameof, (machine, print_, printf)))
-__version__ = '24.06.05'
+__version__ = '24.07.04'
 
 if _dunder_ismain(__name__):  # PYCHOK no cover
 

pygeodesy/karney.py

@@ -143,13 +143,14 @@ from pygeodesy.basics import _copysign, int1s, isint, itemsorted, neg, unsigned0
                              _xgeographiclib, _zip,  _version_info
 from pygeodesy.constants import NAN, _isfinite as _math_isfinite, _0_0, \
                                _1_16th, _1_0, _2_0, _180_0, _N_180_0, _360_0
-from pygeodesy.errors import GeodesicError, _ValueError, _xkwds, _xkwds_get1
+from pygeodesy.errors import GeodesicError, _ValueError, _xkwds, _xkwds_get1, \
+                            _xkwds_kwds, _xkwds_not
 from pygeodesy.fmath import cbrt, fremainder, norm2
 # from pygeodesy.internals import _version_info  # from .basics
-from pygeodesy.interns import _2_, _a12_, _area_, _azi2_, _azi12_, _composite_, \
-                              _lat1_, _lat2_, _lon1_, _lon2_, _m12_, _M12_, \
-                              _M21_, _number_, _s12_, _S12_, _UNDER_, \
-                              _BAR_, NN  # PYCHOK used!
+from pygeodesy.interns import NN, _2_, _a12_, _area_, _azi1_, _azi2_, _azi12_, \
+                             _composite_, _lat1_, _lat2_, _lon1_, _lon2_, \
+                             _m12_, _M12_, _M21_, _number_, _s12_, _S12_, \
+                             _UNDER_, _X_,  _BAR_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv
 from pygeodesy.named import ADict, _NamedBase, _NamedTuple, notImplemented, _Pass
 from pygeodesy.props import deprecated_method, Property_RO
@@ -160,7 +161,7 @@ from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '24.06.27'
+__version__ = '24.07.09'
 
 _K_2_0      = _getenv('PYGEODESY_GEOGRAPHICLIB', _2_) == _2_
 _perimeter_ = 'perimeter'
@@ -211,10 +212,10 @@ class Caps(object):  # PYCHOK
     '''(INTERNAL) Overriden by C{Caps} below.
     '''
     EMPTY          =  0        # formerly aka NONE
-    _CAP_1         =  1 << 0   # for goedesicw only
-    _CAP_1p        =  1 << 1   # for goedesicw only
+    _CAP_1         =  1 << 0   # for goedesici/-w
+    _CAP_1p        =  1 << 1   # for goedesici/-w
     _CAP_2         =  1 << 2
-    _CAP_3         =  1 << 3   # for goedesicw only
+    _CAP_3         =  1 << 3   # for goedesici/-w
 #   _CAP_4         =  1 << 4
 #   _CAP_ALL       =  0x1F
 #   _CAP_MASK      = _CAP_ALL
@@ -233,7 +234,7 @@ class Caps(object):  # PYCHOK
     _DIRECT3       =  AZIMUTH  | LATITUDE | LONGITUDE | _CAP_3   # for goedesicw only
     _INVERSE3      =  AZIMUTH  | DISTANCE | _CAP_1   # for goedesicw only
     _STD           =  STANDARD | _CAP_3   | _CAP_1   # for goedesicw only
-    _STD_LINE      = _STD      | _CAP_2   | _CAP_1p  # for goedesici and -w
+    _STD_LINE      = _STD      | _CAP_2   | _CAP_1p  # for goedesici/-w
 
     LINE_CAPS      = _STD_LINE | REDUCEDLENGTH | GEODESICSCALE  # .geodesici only
 
@@ -248,14 +249,14 @@ class Caps(object):  # PYCHOK
     AZIMUTH_DISTANCE_AREA      = AZIMUTH | DISTANCE | AREA
 
     _ANGLE_ONLY    =  1 << 18  # angular distance C{a12} only
-    _SALPs_CALPs   =  1 << 19  # (INTERNAL) GeodesicExact._GenInverse
+    _S_CALPs_      =  1 << 19  # (INTERNAL) GeodesicExact._GenInverse
 
     _DEBUG_AREA    =  1 << 20  # (INTERNAL) include Line details
     _DEBUG_DIRECT  =  1 << 21  # (INTERNAL) include Direct details
     _DEBUG_INVERSE =  1 << 22  # (INTERNAL) include Inverse details
     _DEBUG_LINE    =  1 << 23  # (INTERNAL) include Line details
     _DEBUG_ALL     = _DEBUG_AREA | _DEBUG_DIRECT | _DEBUG_INVERSE | \
-                     _DEBUG_LINE | _ANGLE_ONLY | _SALPs_CALPs
+                     _DEBUG_LINE | _ANGLE_ONLY | _S_CALPs_
 
     _OUT_ALL       =  ALL
     _OUT_MASK      =  ALL | LONG_UNROLL | REVERSE2 | _DEBUG_ALL
@@ -273,7 +274,7 @@ class Caps(object):  # PYCHOK
         s = []
         for c, C in itemsorted(self.__class__.__dict__):
             if isint(C) and (Csk & C) and int1s(C) == 1 \
-                        and (C in (Caps.REVERSE2, Caps._SALPs_CALPs)
+                        and (C in (Caps.REVERSE2, Caps._S_CALPs_)
                                or c.replace(_UNDER_, NN).isupper()):
                 s.append(c)
         return sep.join(s) if sep else tuple(s)
@@ -310,9 +311,14 @@ and C{ALL} - all of the above.
 
 C{STANDARD} = C{AZIMUTH | DISTANCE | DISTANCE_IN | LATITUDE | LONGITUDE}'''
 
-_KEY2Caps = dict(m12=Caps.REDUCEDLENGTH,  # see GDict._unCaps
-                 M12=Caps.GEODESICSCALE,
-                 M21=Caps.GEODESICSCALE, S12=Caps.AREA)
+_KEY2Caps = dict(azi2=Caps.AZIMUTH,  # see GDict._unCaps
+                 lat2=Caps.LATITUDE,
+                 lon2=Caps.LONGITUDE,
+                 m12 =Caps.REDUCEDLENGTH,
+                 M12 =Caps.GEODESICSCALE,
+                 M21 =Caps.GEODESICSCALE,
+                 s12 =Caps.DISTANCE,
+                 S12 =Caps.AREA)
 
 
 class _CapsBase(_NamedBase):  # in .auxilats, .geodesicx.gxbases
@@ -426,6 +432,12 @@ class GDict(ADict):  # XXX _NamedDict
         '''
         return self._toTuple(Inverse10Tuple, dflt)
 
+    def _toNAN(self, outmask):  # .GeodesicLineExact._GenPosition
+        '''(INTERNAL) Convert this C{GDict} to all C{NAN}s.
+        '''
+        d = dict((n, NAN) for n in GeodSolve12Tuple._Names_)
+        return self.set_(**d)._unCaps(outmask)
+
     @deprecated_method
     def toRhumb7Tuple(self, dflt=NAN):  # PYCHOK no cover
         '''DEPRECATED on 23.12.07, use method C{toRhumb8Tuple}.
@@ -461,6 +473,18 @@ class GDict(ADict):  # XXX _NamedDict
         t  = tuple(_g(self, n, dflt) for n in nTuple._Names_)
         return nTuple(t, iteration=self._iteration)
 
+    def _2X(self, gl, _2X=_X_):  # .Intesectool, .Intersector
+        '''(INTERNAL) Rename attr tail from C{-2} to C{-X} or C{-M}.
+        '''
+        X = GDict(self)
+        for n in (_lat2_, _lon2_, _azi2_, _s12_, _a12_):
+            if n in X:  # X._X = X._2
+                X[n[:-1] + _2X] = X.pop(n)
+            v = getattr(gl, n, X)
+            if v is not X:  # X._2 = gl._2
+                X[n] = v
+        return X
+
     def _unCaps(self, outmask):  # in .geodsolve
         '''(INTERNAL) Remove superfluous items.
         '''
@@ -470,6 +494,19 @@ class GDict(ADict):  # XXX _NamedDict
         return self
 
 
+class GeodSolve12Tuple(_GTuple):
+    '''12-Tuple C{(lat1, lon1, azi1, lat2, lon2, azi2, s12, a12, m12, M12, M21, S12)} with
+       angles C{lat1}, C{lon1}, C{azi1}, C{lat2}, C{lon2} and C{azi2} and arc C{a12} all in
+       C{degrees}, initial C{azi1} and final C{azi2} forward azimuths, distance C{s12} and
+       reduced length C{m12} in C{meter}, area C{S12} in C{meter} I{squared} and geodesic
+       scale factors C{M12} and C{M21}, both C{scalar}, see U{GeodSolve
+       <https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>}.
+    '''
+    # from GeodSolve --help option -f ... lat1 lon1 azi1 lat2 lon2 azi2 s12 a12 m12 M12 M21 S12
+    _Names_ = (_lat1_, _lon1_, _azi1_, _lat2_, _lon2_, _azi2_, _s12_, _a12_, _m12_, _M12_, _M21_, _S12_)
+    _Units_ = (_Lat,   _Lon,   _Azi,   _Lat,   _Lon,   _Azi,   _M,    _Deg,  _Pass, _Pass, _Pass, _M2)
+
+
 class Inverse10Tuple(_GTuple):
     '''10-Tuple C{(a12, s12, salp1, calp1, salp2, calp2, m12, M12, M21, S12)} with arc length
        C{a12} in C{degrees}, distance C{s12} and reduced length C{m12} in C{meter}, area
@@ -687,6 +724,16 @@ def _isfinite(x):  # mimick geomath.Math.isfinite
         return _math_isfinite(x)  # and fabs(x) <= _MAX
 
 
+def _llz2line(line, **llz2):
+    '''(INTERNAL) Set C{line.lat2, .lon2, .azi2} from C{llz2}.
+    '''
+    if llz2:
+        llz2 = _xkwds_not(None, **_xkwds_kwds(llz2, lat2=None, lon2=None, azi2=None))
+        if llz2:
+            line.__dict__.update(llz2)
+    return line
+
+
 def _norm2(x, y):  # mimick geomath.Math.norm
     '''Normalize C{B{x}} and C{B{y}}.
 

pygeodesy/lazily.py

@@ -48,26 +48,27 @@ except ImportError as x:  # Python 2.6-
 from os import getenv as _getenv
 # import sys as _sys  # from .interns
 
-__as__                  = ' as '
-_dunder_all_            = '__all__'  # in .__main__
-_enabled_               = 'enabled'
-_FOR_DOCS               = _getenv('PYGEODESY_FOR_DOCS', NN)  # for epydoc ...
-_i0                     = ()  # PYCHOK empty tuple
-_init__all__            = _FOR_DOCS or _getenv('PYGEODESY_INIT__ALL__', _dunder_all_) == _dunder_all_  # PYCHOK exported
-_lazily_                = 'lazily'
-_lazily_imported_       = _SPACE_(_HASH_, _lazily_, 'imported')
-_PYGEODESY_GEOCONVERT_  = 'PYGEODESY_GEOCONVERT'  # PYCHOK .mgrs, test.bases
-_PYGEODESY_GEODSOLVE_   = 'PYGEODESY_GEODSOLVE'   # PYCHOK .geodsolve, test.bases
-_PYGEODESY_LAZY_IMPORT_ = 'PYGEODESY_LAZY_IMPORT'
-_PYGEODESY_RHUMBSOLVE_  = 'PYGEODESY_RHUMBSOLVE'  # PYCHOK .rhumb.solve, test.bases
-_PYTHON_X_DEV           =  getattr(_sys, '_xoptions', {}).get('dev',  # Python 3.2+
+__as__                    = ' as '
+_dunder_all_              = '__all__'  # in .__main__
+_enabled_                 = 'enabled'
+_FOR_DOCS                 = _getenv('PYGEODESY_FOR_DOCS', NN)  # for epydoc ...
+_i0                       = ()  # PYCHOK empty tuple
+_init__all__              = _FOR_DOCS or _getenv('PYGEODESY_INIT__ALL__', _dunder_all_) == _dunder_all_  # PYCHOK exported
+_lazily_                  = 'lazily'
+_lazily_imported_         = _SPACE_(_HASH_, _lazily_, 'imported')
+_PYGEODESY_GEOCONVERT_    = 'PYGEODESY_GEOCONVERT'  # PYCHOK .mgrs, test.bases
+_PYGEODESY_GEODSOLVE_     = 'PYGEODESY_GEODSOLVE'   # PYCHOK .geodsolve, test.bases
+_PYGEODESY_INTERSECTTOOL_ = 'PYGEODESY_INTERSECTTOOL'  # PYCHOK .intersectool, test.bases
+_PYGEODESY_LAZY_IMPORT_   = 'PYGEODESY_LAZY_IMPORT'
+_PYGEODESY_RHUMBSOLVE_    = 'PYGEODESY_RHUMBSOLVE'  # PYCHOK .rhumb.solve, test.bases
+_PYTHON_X_DEV             =  getattr(_sys, '_xoptions', {}).get('dev',  # Python 3.2+
                           _getenv('PYTHONDEVMODE', NN))  # PYCHOK exported
-_sys_version_info2      = _sys.version_info[:2]  # in .basics, .fmath, ...
-_unlazy = _unLazy0      = _isfrozen or _sys_version_info2 < (3, 7)  # PYCHOK mod.__getattr__ 3.7+
-_WARNINGS_X_DEV         = _getenv('PYGEODESY_WARNINGS', NN) and (
-                          _PYTHON_X_DEV or bool(_sys.warnoptions))  # PYCHOK .props
+_sys_version_info2        = _sys.version_info[:2]  # in .basics, .fmath, ...
+_unlazy = _unLazy0        = _isfrozen or _sys_version_info2 < (3, 7)  # PYCHOK mod.__getattr__ 3.7+
+_WARNINGS_X_DEV           = _getenv('PYGEODESY_WARNINGS', NN) and (
+                            _PYTHON_X_DEV or bool(_sys.warnoptions))  # PYCHOK .props
 # @module_property[_RO?] <https://GitHub.com/jtushman/proxy_tools/>
-isLazy                  =  None  # see @var isLazy in .__init__
+isLazy                    =  None  # see @var isLazy in .__init__
 
 
 class LazyAttributeError(AttributeError):
@@ -283,7 +284,8 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                           fsums=_i('Fsum', 'DivMod2Tuple', 'Fsum2Tuple', 'ResidualError',
                                    'fsum', 'fsum_', 'fsumf_', 'fsum1', 'fsum1_', 'fsum1f_'),
                            gars=_i('Garef', 'GARSError'),
-                      geodesici=_i('Intersector', 'Intersector5Tuple', 'XDist'),
+                      geodesici=_i('Intersectool', 'Intersectool5Tuple', 'Middle5Tuple',
+                                   'Intersector',  'Intersector5Tuple',  'XDict'),
                       geodesicw=_i('Geodesic', 'GeodesicLine', 'Geodesic_WGS84'),
                       geodesicx=_i('gx', 'gxarea', 'gxbases', 'gxline',  # modules
                                    'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'),
@@ -409,7 +411,7 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                                          'HeightIDW', 'HeightIDW2', 'HeightIDW3', 'Helmert7Tuple',
                                          'Lam_', 'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple',
                                          'Phi_', 'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple',
-                                         'Transform7Tuple', 'TriAngle4Tuple', 'UtmUps4Tuple'),
+                                         'Transform7Tuple', 'TriAngle4Tuple', 'UtmUps4Tuple', 'XDist'),
                  deprecated_consterns=_i('EPS1_2', 'MANTIS', 'OK'),
                      deprecated_datum=_i('Curvature2Tuple', 'Datum',  'Ellipsoid',  'Transform',  # assert
                                                             'Datums', 'Ellipsoids', 'Transforms',
@@ -519,7 +521,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.06.19'
+__version__ = '24.07.09'
 
 
 def _ALL_OTHER(*objs):

pygeodesy/ltpTuples.py

@@ -36,7 +36,7 @@ from pygeodesy.vector3d import Vector3d
 # from math import cos, radians  # from .utily
 
 __all__ = _ALL_LAZY.ltpTuples
-__version__ = '24.06.15'
+__version__ = '24.06.28'
 
 _aer_        = 'aer'
 _alt_        = 'alt'
@@ -349,7 +349,7 @@ class Aer(_AbcBase):
                                 number of (decimal) digits, unstripped
                                 (C{int}), C{B{fmt}='[]'} the enclosing
                                 backets format (C{str}) and separator
-                                C{B{sep}=', '} to join (C{str}).
+                                C{B{sep}=", "} to join (C{str}).
 
            @return: This AER as "[degrees360, degrees90, meter]" (C{str}).
         '''
@@ -572,7 +572,7 @@ class Ned(_AbcBase):
                                 number of (decimal) digits, unstripped
                                 (C{int}), C{B{fmt}='[]'} the enclosing
                                 backets format (C{str}) and separator
-                                C{B{sep}=', '} to join (C{str}).
+                                C{B{sep}=", "} to join (C{str}).
 
            @return: This NED as "[meter, meter, meter]" (C{str}).
         '''
@@ -659,7 +659,7 @@ class _Vector3d(Vector3d):
                                 number of (decimal) digits, unstripped
                                 (C{int}), C{B{fmt}='[]'} the enclosing
                                 backets format (C{str}) and separator
-                                C{B{sep}=', '} to join (C{str}).
+                                C{B{sep}=", "} to join (C{str}).
 
            @return: This XYZ as "[meter, meter, meter]" (C{str}).
         '''