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

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.05.31'
+__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_2         =  1 << 2
-    _CAP_3         =  1 << 3   # 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 goedesici/-w
 #   _CAP_4         =  1 << 4
 #   _CAP_ALL       =  0x1F
 #   _CAP_MASK      = _CAP_ALL
@@ -233,7 +234,9 @@ 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_1p   # for goedesicw only
+    _STD_LINE      = _STD      | _CAP_2   | _CAP_1p  # for goedesici/-w
+
+    LINE_CAPS      = _STD_LINE | REDUCEDLENGTH | GEODESICSCALE  # .geodesici only
 
     LINE_OFF       =  1 << 15  # Line without updates from parent geodesic or rhumb
     LONG_UNROLL    =  1 << 16  # unroll C{lon2} in .Direct and .Position
@@ -246,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
@@ -271,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)
@@ -308,6 +311,15 @@ and C{ALL} - all of the above.
 
 C{STANDARD} = C{AZIMUTH | DISTANCE | DISTANCE_IN | LATITUDE | LONGITUDE}'''
 
+_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
     '''(INTERNAL) Base class for C{[_]Geodesic*Exact}.
@@ -320,11 +332,13 @@ class _CapsBase(_NamedBase):  # in .auxilats, .geodesicx.gxbases
     EMPTY         = Caps.EMPTY  # aka NONE
     GEODESICSCALE = Caps.GEODESICSCALE
     LATITUDE      = Caps.LATITUDE
+    LINE_CAPS     = Caps.LINE_CAPS
     LINE_OFF      = Caps.LINE_OFF
     LONGITUDE     = Caps.LONGITUDE
     LONG_UNROLL   = Caps.LONG_UNROLL
     REDUCEDLENGTH = Caps.REDUCEDLENGTH
     STANDARD      = Caps.STANDARD
+    _STD_LINE     = Caps._STD_LINE  # for geodesici
 
     _caps         = 0  # None
     _debug        = 0  # or Caps._DEBUG_...
@@ -418,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}.
@@ -453,6 +473,39 @@ 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.
+        '''
+        for k, m in _KEY2Caps.items():
+            if k in self and not (outmask & m):
+                self.pop(k)  # delattr(self, k)
+        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
@@ -671,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}}.
 
@@ -882,7 +945,7 @@ def _unroll2(lon1, lon2, wrap=False):  # see .ellipsoidalBaseDI._intersects2
     '''Unroll B{C{lon2 - lon1}} like C{geodesic.Geodesic.Inverse}.
 
        @return: 2-Tuple C{(B{lon2} - B{lon1}, B{lon2})} with B{C{lon2}}
-                unrolled if B{C{wrap}} is C{True}, normalized otherwise.
+                unrolled if C{B{wrap} is True}, normalized otherwise.
     '''
     if wrap:
         d, t = _diff182(lon1, lon2)

pygeodesy/ktm.py

@@ -67,7 +67,7 @@ from cmath import polar
 from math import atan2, asinh, cos, cosh, degrees, fabs, sin, sinh, sqrt, tanh
 
 __all__ = _ALL_LAZY.ktm
-__version__ = '24.05.24'
+__version__ = '24.06.11'
 
 
 class KTMError(_ValueError):
@@ -119,18 +119,16 @@ class KTransverseMercator(_NamedBase):
                                    raiser=False, **TMorder_name):
         '''New L{KTransverseMercator}.
 
-           @kwarg a_earth: This rhumb's earth (L{Ellipsoid}, L{Ellipsoid2},
-                           L{a_f2Tuple}, L{Datum}, 2-tuple (C{a, f})) or the
-                           equatorial radius (C{scalar}, C{meter}).
-           @kwarg f: The ellipsoid's flattening (C{scalar}), iff B{C{a_earth}}
-                     is a C{scalar}, ignored otherwise.
+           @kwarg a_earth: This rhumb's earth (L{Ellipsoid}, L{Ellipsoid2}, L{a_f2Tuple},
+                           L{Datum}, 2-tuple (C{a, f})) or the equatorial radius (C{meter}).
+           @kwarg f: The ellipsoid's flattening (C{scalar}), required if B{C{a_earth}} is
+                     is C{meter}, ignored otherwise.
            @kwarg lon0: The central meridian (C{degrees180}).
            @kwarg k0: Central scale factor (C{scalar}).
-           @kwarg raiser: If C{True}, throw a L{KTMError} for C{forward}
-                          singularities (C{bool}).
-           @kwarg TMorder_name: Optional C{B{name}=NN} (C{str}) and optional
-                          keyword argument C{B{TMorder}=6} for the order of
-                          this L{KTransverseMercator}, see property C{TMorder}.
+           @kwarg raiser: If C{True}, throw a L{KTMError} for C{forward} singularities (C{bool}).
+           @kwarg TMorder_name: Optional C{B{name}=NN} (C{str}) and optional keyword argument
+                          C{B{TMorder}=6} for the order of this L{KTransverseMercator}, see
+                          property C{TMorder}.
 
            @raise KTMError: Invalid B{C{a_earth}}, B{C{f}} or B{C{TMorder}}.
         '''
@@ -229,14 +227,13 @@ class KTransverseMercator(_NamedBase):
            @arg lon0: Central meridian of the projection (C{degrees180}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-           @return: L{Forward4Tuple}C{(easting, northing, gamma, scale)}
-                    with C{easting} and C{northing} in C{meter}, unfalsed, the
+           @return: L{Forward4Tuple}C{(easting, northing, gamma, scale)} with
+                    C{easting} and C{northing} in C{meter}, unfalsed, the
                     meridian convergence C{gamma} at point in C{degrees180}
                     and the C{scale} of projection at point C{scalar}.  Any
                     value may be C{NAN}, C{NINF} or C{INF} for singularities.
 
-           @raise KTMError: For singularities, iff property C{raiser} is
-                            C{True}.
+           @raise KTMError: For singularities, iff property C{raiser} is C{True}.
         '''
         lat, _lat = _unsigned2(_fix90(lat - self._lat0))
         lon, _    = _diff182((self.lon0 if lon0 is None else lon0), lon)
@@ -343,7 +340,7 @@ class KTransverseMercator(_NamedBase):
            @arg lat0: Latitude of the central parallel (C{degrees90}).
            @arg lon0: Longitude of the central parallel (C{degrees180}).
 
-           @return: 2-Tuple C{(lat0, lon0)} of the previous central
+           @return: 2-Tuple C{(lat0, lon0)} with the previous central
                     parallel and meridian.
 
            @raise KTMError: Invalid B{C{lat0}} or B{C{lon0}}.

pygeodesy/latlonBase.py

@@ -54,7 +54,7 @@ from contextlib import contextmanager
 from math import asin, cos, degrees, fabs, radians
 
 __all__ = _ALL_LAZY.latlonBase
-__version__ = '24.06.07'
+__version__ = '24.06.11'
 
 _formy = _MODS.into(formy=__name__)
 
@@ -143,17 +143,17 @@ class LatLonBase(_NamedBase):
            bounding box centered at this location.
 
            @arg wide: Longitudinal box width (C{meter}, same units as
-                      B{C{radius}} or C{degrees} if B{C{radius}} is C{None}).
+                      B{C{radius}} or C{degrees} if C{B{radius} is None}).
            @arg tall: Latitudinal box size (C{meter}, same units as
-                      B{C{radius}} or C{degrees} if B{C{radius}} is C{None}).
+                      B{C{radius}} or C{degrees} if C{B{radius} is None}).
            @kwarg radius: Mean earth radius (C{meter}) or C{None} if I{both}
                           B{C{wide}} and B{C{tall}} are in C{degrees}.
            @kwarg height: Height for C{latlonSW} and C{latlonNE} (C{meter}),
                           overriding the point's height.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-           @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)}, the
-                    lower-left and upper-right corner (C{LatLon}).
+           @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)}, the lower-left
+                    and upper-right corner (C{LatLon}).
 
            @see: U{https://www.Movable-Type.co.UK/scripts/latlong-db.html}
         '''
@@ -1396,13 +1396,12 @@ class LatLonBase(_NamedBase):
                           (C{meter}, conventionally).
            @kwarg Cartesian: Optional class to return the geocentric
                              coordinates (C{Cartesian}) or C{None}.
-           @kwarg Cartesian_kwds: Optional, additional B{C{Cartesian}}
-                                  keyword arguments, ignored if
-                                  C{B{Cartesian} is None}.
+           @kwarg Cartesian_kwds: Optional, additional B{C{Cartesian}} keyword
+                                  arguments, ignored if C{B{Cartesian} is None}.
 
-           @return: A B{C{Cartesian}} or if B{C{Cartesian}} is C{None},
-                    an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M,
-                    datum)} with C{C=0} and C{M} if available.
+           @return: A B{C{Cartesian}} or if B{C{Cartesian} is None}, an
+                    L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
+                    with C{C=0} and C{M} if available.
 
            @raise TypeError: Invalid B{C{Cartesian}} or B{C{Cartesian_kwds}}.
 
@@ -1512,11 +1511,10 @@ class LatLonBase(_NamedBase):
                        additional B{C{Nvector}} keyword arguments, ignored if
                        C{B{Nvector} is None}.
 
-           @return: An B{C{Nvector}} or a L{Vector4Tuple}C{(x, y, z, h)} if
-                    B{C{Nvector}} is C{None}.
+           @return: An named B{C{Nvector}} or if C{B{Nvector} is None} a named
+                    L{Vector4Tuple}C{(x, y, z, h)}.
 
-           @raise TypeError: Invalid B{C{h}}, B{C{Nvector}} or
-                             B{C{name_Nvector_kwds}} item.
+           @raise TypeError: Invalid B{C{h}}, B{C{Nvector}} or B{C{name_Nvector_kwds}}.
 
            @see: Methods C{toCartesian}, C{toVector} and C{toVector3d}.
         '''
@@ -1548,7 +1546,7 @@ class LatLonBase(_NamedBase):
 
            @return: This point in the specified C{B{form}at}, etc. (C{str} or
                     a 2- or 3-tuple C{(lat_str, lon_str[, height_str])} if
-                    C{B{joined}=NN} or C{B{joined}=None}).
+                    B{C{joined}} is C{NN} or C{None}).
 
            @see: Function L{pygeodesy.latDMS} or L{pygeodesy.lonDMS} for more
                  details about keyword arguments C{B{form}at}, C{B{prec}ision},
@@ -1569,10 +1567,10 @@ class LatLonBase(_NamedBase):
            @kwarg Vector_kwds: Optional, additional B{C{Vector}} keyword
                                arguments, ignored if C{B{Vector} is None}.
 
-           @return: A named B{C{Vector}} or if B{C{Vector}} is C{None} a
+           @return: A named B{C{Vector}} or if C{B{Vector} is None} a
                     named L{Vector3Tuple}C{(x, y, z)}.
 
-           @raise TypeError: Invalid B{C{Vector}} or B{C{Vector_kwds}} item.
+           @raise TypeError: Invalid B{C{Vector}} or B{C{Vector_kwds}}.
 
            @see: Methods C{toCartesian}, C{toNvector} and C{toVector3d}.
         '''
@@ -1587,7 +1585,7 @@ class LatLonBase(_NamedBase):
 
            @return: Named, unit vector or vector (L{Vector3d}).
 
-           @raise TypeError: Invalid B{C{Vector3d_kwds}} item.
+           @raise TypeError: Invalid B{C{Vector3d_kwds}}.
 
            @see: Methods C{toCartesian}, C{toNvector} and C{toVector}.
         '''

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,6 +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('Intersectool', 'Intersectool5Tuple', 'Middle5Tuple',
+                                   'Intersector',  'Intersector5Tuple',  'XDict'),
                       geodesicw=_i('Geodesic', 'GeodesicLine', 'Geodesic_WGS84'),
                       geodesicx=_i('gx', 'gxarea', 'gxbases', 'gxline',  # modules
                                    'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'),
@@ -367,9 +370,9 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                           units=_i('Band', 'Bearing', 'Bearing_', 'Bool',
                                    'Degrees', 'Degrees_', 'Degrees2', 'Distance', 'Distance_', 'Easting', 'Epoch',
                                    'Feet', 'FIx', 'Float_', 'Height', 'Height_', 'HeightX', 'Int_',
-                                   'Lam', 'Lam_', 'Lat', 'Lat_', 'Lon', 'Lon_',
+                                   'Lam', 'Lamd', 'Lat', 'Lat_', 'Lon', 'Lon_',
                                    'Meter', 'Meter_', 'Meter2', 'Meter3', 'Northing', 'Number_',
-                                   'Phi', 'Phi_', 'Precision_', 'Radians', 'Radians_', 'Radians2',
+                                   'Phi', 'Phid', 'Precision_', 'Radians', 'Radians_', 'Radians2',
                                    'Radius_', 'Scalar', 'Scalar_', 'Zone'),
                       unitsBase=_i('Float', 'Int', 'Radius', 'Str'),
                             ups=_i('Ups', 'UPSError', 'parseUPS5', 'toUps8', 'upsZoneBand5'),
@@ -406,13 +409,13 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                      deprecated_bases=_i('LatLonHeightBase', 'points2'),
                    deprecated_classes=_i('ClipCS3Tuple', 'EasNorExact4Tuple', 'EcefCartesian', 'Fn_rt',
                                          'HeightIDW', 'HeightIDW2', 'HeightIDW3', 'Helmert7Tuple',
-                                         'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple',
-                                         'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple',
-                                         'Transform7Tuple', 'TriAngle4Tuple', 'UtmUps4Tuple'),
+                                         'Lam_', 'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple',
+                                         'Phi_', 'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple',
+                                         'Transform7Tuple', 'TriAngle4Tuple', 'UtmUps4Tuple', 'XDist'),
                  deprecated_consterns=_i('EPS1_2', 'MANTIS', 'OK'),
                      deprecated_datum=_i('Curvature2Tuple', 'Datum',  'Ellipsoid',  'Transform',  # assert
                                                             'Datums', 'Ellipsoids', 'Transforms',
-                                         'R_M', 'R_MA', 'R_MB', 'R_KM', 'R_NM', 'R_SM', 'R_FM', 'R_VM'),
+                                         'R_FM', 'R_KM', 'R_M', 'R_MA', 'R_MB', 'R_NM', 'R_SM', 'R_VM'),
                  deprecated_functions=_i('anStr', 'areaof', 'atand', 'bounds',  # most of the DEPRECATED functions, except ...
                                          'clipCS3', 'clipDMS', 'clipStr', 'collins', 'copysign',  # ...  ellipsoidal, spherical flavors
                                          'decodeEPSG2', 'encodeEPSG', 'enStr2', 'equirectangular_', 'equirectangular3',
@@ -518,7 +521,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.06.05'
+__version__ = '24.07.09'
 
 
 def _ALL_OTHER(*objs):

pygeodesy/lcc.py

@@ -41,14 +41,14 @@ from pygeodesy.namedTuples import EasNor3Tuple, LatLonDatum3Tuple, \
                                   LatLon2Tuple, _LL4Tuple, PhiLam2Tuple
 from pygeodesy.props import deprecated_method, Property, Property_RO, _update_all
 from pygeodesy.streprs import Fmt, _fstrENH2, _xzipairs
-from pygeodesy.units import Easting, Height, _heigHt,  Lam_, Northing, Phi_, \
+from pygeodesy.units import Easting, Height, _heigHt,  Lamd, Northing, Phid, \
                             Scalar_
 from pygeodesy.utily import atan1, degrees90, degrees180, sincos2, tanPI_2_2
 
 from math import atan, fabs, log, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.lcc
-__version__ = '24.06.09'
+__version__ = '24.06.24'
 
 _E0_   = 'E0'
 _N0_   = 'N0'
@@ -107,8 +107,8 @@ class Conic(_NamedEnumItem):
             _xinstanceof(_LLEB, latlon0=latlon0)
             self._phi0, self._lam0 = latlon0.philam
 
-            self._par1 = Phi_(par1=par1)
-            self._par2 = self._par1 if par2 is None else Phi_(par2=par2)
+            self._par1 = Phid(par1=par1)
+            self._par2 = self._par1 if par2 is None else Phid(par2=par2)
 
             if k0 != 1:
                 self._k0 = Scalar_(k0=k0)
@@ -117,7 +117,7 @@ class Conic(_NamedEnumItem):
             if N0:
                 self._N0 = Easting(N0=N0, falsed=True)
             if opt3:
-                self._opt3 = Lam_(opt3=opt3)
+                self._opt3 = Lamd(opt3=opt3)
 
             self.toDatum(latlon0.datum)._dup2(self)
             self._register(Conics, name)
@@ -278,20 +278,19 @@ class Conic(_NamedEnumItem):
 
         return c
 
-    def toStr(self, prec=8, name=NN, **unused):  # PYCHOK expected
+    def toStr(self, prec=8, **name):  # PYCHOK expected
         '''Return this conic as a string.
 
            @kwarg prec: Number of (decimal) digits, unstripped (C{int}).
-           @kwarg name: Overriding name (C{str}) or C{None} to exclude
-                        this conic's name.
+           @kwarg name: Overriding C{B{name}=NN} (C{str}) or C{None} to
+                        exclude this conic's name.
 
            @return: Conic attributes (C{str}).
         '''
-        a = [name, prec, _lat0_, _lon0_, _par1_, _par2_,
-                         _E0_, _N0_, _k0_, _SP_]
+        a = [_lat0_, _lon0_, _par1_, _par2_, _E0_, _N0_, _k0_, _SP_]
         if self._SP == 1:
             _ = a.pop(a.index(_par2_))
-        return self._instr(datum=self.datum, *a)
+        return self._instr(datum=self.datum, prec=prec, *a, **name)
 
     def _dup2(self, c):
         '''(INTERNAL) Copy this conic to C{c}.
@@ -537,22 +536,21 @@ class Lcc(_NamedBase):
     def toLatLon(self, LatLon=None, datum=None, height=None, **LatLon_kwds):
         '''Convert this L{Lcc} to an (ellipsoidal) geodetic point.
 
-           @kwarg LatLon: Optional, ellipsoidal class to return the
-                          geodetic point (C{LatLon}) or C{None}.
-           @kwarg datum: Optional datum to use, otherwise use this
-                         B{C{Lcc}}'s conic.datum (L{Datum}, L{Ellipsoid},
-                         L{Ellipsoid2} or L{a_f2Tuple}).
-           @kwarg height: Optional height for the point, overriding
-                          the default height (C{meter}).
-           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                               arguments, ignored if C{B{LatLon} is None}.
+           @kwarg LatLon: Optional, ellipsoidal class to return the geodetic
+                          point (C{LatLon}) or C{None}.
+           @kwarg datum: Optional datum to use, otherwise use this B{C{Lcc}}'s
+                         conic.datum (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or
+                         L{a_f2Tuple}).
+           @kwarg height: Optional height for the point, overriding the default height
+                          (C{meter}).
+           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,
+                               ignored if C{B{LatLon} is None}.
 
-           @return: The point (B{C{LatLon}}) or a
-                    L{LatLon4Tuple}C{(lat, lon, height, datum)}
-                    if B{C{LatLon}} is C{None}.
+           @return: The point (B{C{LatLon}}) or if C{B{LatLon} is None}, a
+                    L{LatLon4Tuple}C{(lat, lon, height, datum)}.
 
-           @raise TypeError: If B{C{LatLon}} or B{C{datum}} is
-                             not ellipsoidal or not valid.
+           @raise TypeError: If B{C{LatLon}} or B{C{datum}} is not ellipsoidal or
+                             not valid.
         '''
         if LatLon:
             _xsubclassof(_LLEB, LatLon=LatLon)
@@ -622,13 +620,12 @@ def toLcc(latlon, conic=Conics.WRF_Lb, height=None, Lcc=Lcc,
        @kwarg height: Optional height for the point, overriding the
                       default height (C{meter}).
        @kwarg Lcc: Class to return the I{Lambert} location (L{Lcc}).
-       @kwarg name_Lcc_kwds: Optional C{B{name}=NN} (C{str}) for the
-                   location and optional, additional B{C{Lcc}} keyword
-                   arguments, ignored if B{C{Lcc}} is C{None}.
+       @kwarg name_Lcc_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                   additional B{C{Lcc}} keyword arguments, ignored if
+                   B{C{Lcc} is None}.
 
-       @return: The I{Lambert} location (L{Lcc}) or an
-                L{EasNor3Tuple}C{(easting, northing, height)} if
-                C{B{Lcc} is None}.
+       @return: The I{Lambert} location (L{Lcc}) or if C{B{Lcc} is None},
+                an L{EasNor3Tuple}C{(easting, northing, height)}.
 
        @raise TypeError: If B{C{latlon}} is not ellipsoidal.
     '''

pygeodesy/ltp.py

@@ -44,7 +44,7 @@ from pygeodesy.vector3d import _ALL_LAZY, Vector3d
 # from math import fabs, floor as _floor  # from .fmath, .fsums
 
 __all__ = _ALL_LAZY.ltp
-__version__ = '24.06.07'
+__version__ = '24.06.11'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -154,7 +154,7 @@ class Attitude(_NamedBase):
                        additional B{C{Vector}} keyword arguments, ignored if
                        C{B{Vector} is None}.
 
-           @return: A named B{C{Vector}} instance or if B{C{Vector}} is C{None},
+           @return: A named B{C{Vector}} instance or if C{B{Vector} is None},
                     a named L{Vector3Tuple}C{(x, y, z)}.
 
            @raise AttitudeError: Invalid B{C{x_xyz}}, B{C{y}} or B{C{z}}.
@@ -419,13 +419,12 @@ class LocalCartesian(_NamedBase):
            @kwarg latlonh0: The (geodetic) origin (C{LatLon}, L{LatLon4Tuple}, L{Ltp}
                             L{LocalCartesian} or L{Ecef9Tuple}) or the C{scalar}
                             latitude of the (goedetic) origin (C{degrees}).
-           @kwarg lon0: Longitude of the (goedetic) origin (C{degrees}) for C{scalar}
-                        B{C{latlonh0}}, ignored otherwise.
+           @kwarg lon0: Longitude of the (goedetic) origin (C{degrees}), required if
+                        B{C{latlonh0}} is C{scalar}, ignored otherwise.
            @kwarg height0: Optional height (C{meter}, conventionally) at the (goedetic)
                            origin perpendicular to and above (or below) the ellipsoid's
-                           surface and for C{scalar} B{C{latlonh0}}, ignored otherwise.
-           @kwarg ecef: An ECEF converter (L{EcefKarney} I{only}) for C{scalar}
-                        B{C{latlonh0}}, ignored otherwise.
+                           surface, like B{C{lon0}}.
+           @kwarg ecef: An ECEF converter (L{EcefKarney} I{only}), like B{C{lon0}}.
            @kwarg lon00_name: Optional C{B{name}=NN} (C{str}) and keyword argument
                         C{B{lon00}=B{lon0}} for the arbitrary I{polar} longitude
                         (C{degrees}), see method C{reverse} and property C{lon00}
@@ -1104,7 +1103,7 @@ def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector_kwds):
                    additional B{C{Vector}} keyword arguments, ignored if
                    C{B{Vector} is None}.
 
-       @return: A named B{C{Vector}} instance or if B{C{Vector}} is C{None},
+       @return: A named B{C{Vector}} instance or if C{B{Vector} is None},
                 a named L{Vector3Tuple}C{(x, y, z)}.
 
        @raise AttitudeError: Invalid B{C{tilt}}, B{C{yaw}} or B{C{roll}}.