pygeodesy 25.4.25__py2.py3-none-any.whl → 25.5.5__py2.py3-none-any.whl

pygeodesy/latlonBase.py

@@ -17,12 +17,13 @@ from pygeodesy.constants import EPS, EPS0, EPS1, EPS4, INT0, R_M, \
 from pygeodesy.datums import _spherical_datum
 from pygeodesy.dms import F_D, F_DMS, latDMS, lonDMS, parse3llh
 # from pygeodesy.ecef import EcefKarney  # _MODS
+from pygeodesy.ecefLocals import _EcefLocal
 from pygeodesy.errors import _AttributeError, IntersectionError, \
                              _incompatible, _IsnotError, _TypeError, \
                              _ValueError, _xattr, _xdatum, _xError, \
                              _xkwds, _xkwds_get, _xkwds_item2, _xkwds_not
 # from pygeodesy.fmath import favg  # _MODS
-# from pygeodesy import formy as _formy  # .MODS.into
+# from pygeodesy import formy as _formy  # _MODS.into
 from pygeodesy.internals import _passarg, typename
 from pygeodesy.interns import NN, _COMMASPACE_, _concentric_, _height_, \
                              _intersection_, _LatLon_, _m_, _negative_, \
@@ -30,7 +31,7 @@ from pygeodesy.interns import NN, _COMMASPACE_, _concentric_, _height_, \
 # from pygeodesy.iters import PointsIter, points2  # _MODS
 # from pygeodesy.karney import Caps  # _MODS
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _name2__, _NamedBase, _NamedLocal,  Fmt
+from pygeodesy.named import _name2__, _NamedBase,  Fmt
 from pygeodesy.namedTuples import Bounds2Tuple, LatLon2Tuple, PhiLam2Tuple, \
                                   Trilaterate5Tuple, Vector3Tuple
 # from pygeodesy.nvectorBase import _N_vector_  # _MODS
@@ -48,12 +49,12 @@ from contextlib import contextmanager
 from math import asin, cos, degrees, fabs, radians
 
 __all__ = _ALL_LAZY.latlonBase
-__version__ = '25.04.21'
+__version__ = '25.04.28'
 
 _formy = _MODS.into(formy=__name__)
 
 
-class LatLonBase(_NamedBase, _NamedLocal):
+class LatLonBase(_NamedBase, _EcefLocal):
     '''(INTERNAL) Base class for ellipsoidal and spherical C{satLon}s.
     '''
     _clipid = INT0  # polygonal clip, see .booleans
@@ -411,7 +412,7 @@ class LatLonBase(_NamedBase, _NamedLocal):
 
            @raise TypeError: Invalid B{C{delta}}, B{C{LatLon}} or B{C{LatLon_kwds}} item.
         '''
-        t = self._Ltp._local2ecef(delta, nine=True)
+        t = self._ltp._local2ecef(delta, nine=True)  # _EcefLocal._ltp
         return t.toLatLon(LatLon=LatLon, **_xkwds(LatLon_kwds, name=self.name))
 
     def _distanceTo(self, func, other, radius=None, **kwds):
@@ -901,6 +902,8 @@ class LatLonBase(_NamedBase, _NamedLocal):
             _update_all(self)
             self._lon = lon
 
+#   _ltp = _EcefLocal._ltp(self)
+
     def nearestOn6(self, points, closed=False, height=None, wrap=False):
         '''Locate the point on a path or polygon closest to this point.
 

pygeodesy/lazily.py

@@ -35,9 +35,9 @@ from pygeodesy.internals import _caller3, _envPYGEODESY, _headof, printf, _tailo
 #                               _MODS_Base, _MODS.sys_version_info2
 from pygeodesy.interns import _attribute_, _by_, _COLONSPACE_, _COMMASPACE_, _DALL_, \
                               _DMAIN_, _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \
-                              _immutable_, _line_, _module_, NN, _no_, _not_, _or_, \
+                              _HASH_, _immutable_, _line_, _module_, NN, _no_, _not_, \
                               _pygeodesy_, _pygeodesy_abspath_, _SPACE_, _SUB_PACKAGES, \
-                              _UNDER_, _version_,  _sys, _intern  # function, _1_, _HASH_
+                              _or_, _UNDER_, _version_,  _sys, _intern  # function, _1_
 try:
     from importlib import import_module
 except ImportError as x:  # Python 2.6-
@@ -47,6 +47,7 @@ except ImportError as x:  # Python 2.6-
 _a0                = ()  # PYCHOK empty tuple
 _asSPACED_         = ' as '
 _FOR_DOCS          = _envPYGEODESY('FOR_DOCS')  # for epydoc ...
+_imported_         = 'imported'
 _init__all__       = _FOR_DOCS or _envPYGEODESY('_init__all__', _DALL_) == _DALL_  # PYCHOK exported
 _lazily_           = 'lazily'
 _PYTHON_X_DEV      =  getattr(_sys.flags, 'dev_mode', False)  # PYCHOK Python 3.2+
@@ -215,6 +216,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'parseDDDMMSS', 'parseDMS', 'parseDMS2', 'parse3llh', 'parseRad', 'precision', 'toDMS'),
                            ecef=_a('EcefError', 'EcefFarrell21', 'EcefFarrell22', 'EcefKarney', 'EcefMatrix',
                                    'EcefSudano', 'Ecef9Tuple', 'EcefVeness', 'EcefYou'),
+                     ecefLocals=_a(),  # module only
                      elevations=_a('Elevation2Tuple', 'GeoidHeight2Tuple',
                                    'elevation2', 'geoidHeight2'),
                 ellipsoidalBase=_a(),  # module only
@@ -239,7 +241,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'crosserrors', 'exception_chaining', 'isError', 'limiterrors', 'rangerrors'),
                             etm=_a('Etm', 'ETMError', 'ExactTransverseMercator',
                                    'parseETM5', 'toEtm8'),
-                          fmath=_a('Fdot', 'Fhorner', 'Fhypot', 'Fpolynomial', 'Fpowers', 'Fcbrt', 'Froot', 'Fsqrt',
+                          fmath=_a('Fdot', 'Fdot_', 'Fhorner', 'Fhypot', 'Fpolynomial', 'Fpowers', 'Fcbrt', 'Froot', 'Fsqrt',
                                    'bqrt', 'cbrt', 'cbrt2', 'euclid', 'euclid_',
                                    'facos1', 'fasin1', 'fatan', 'fatan1', 'fatan2', 'favg',
                                    'fdot', 'fdot_', 'fdot3', 'fma', 'fmean', 'fmean_', 'fhorner', 'fidw', 'f2mul_',
@@ -477,19 +479,17 @@ class _ALL_MODS(_internals._MODS_Base):
         return _sys.modules.get(name, None)
 
     def into(self, **mod_DNAME):
-        '''Lazily import module C{mod} into module C{_DNAME_}
-           and set C{_DNAME_._mod} to module C{mod}, I{once}.
+        '''Deferred import of module C{mod} into module C{_DNAME_}
+           and overwrite C{_DNAME_._mod} to module C{mod}, I{once}
+           at the first access of an attribute of module C{mod}.
         '''
+    #   assert len(mod_DNAME) == 1
+    #   mod, dun = mod_DNAME.popitem()
+
         class _Into(object):
 
             def __getattr__(unused, name):
-                mod, dun = self.errors._xkwds_item2(mod_DNAME)
-                _mod = _UNDER_(NN, mod)
-                d =  self.getmodule(dun)  # '__main__' OK
-                i = _getmodattr(d, _mod, dun)
-                assert isinstance(i, _Into)
-                m =  self.getmodule(mod)
-                setattr(d, _mod, m)  # overwrite C{d._mod}
+                m = _getmodinto(mod_DNAME, _Into)
                 return getattr(m, name)
 
         return _Into()
@@ -510,7 +510,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '25.04.21'
+__version__ = '25.04.30'
 
 
 def _ALL_OTHER(*objs):
@@ -599,11 +599,29 @@ def _getmodattr(m, name, mod=_pygeodesy_):
     try:
         return getattr(m, name)
     except AttributeError:
-        name = _DOT_(mod, name)
+        name = _DOT_(typename(m, mod), name)
         # <https://GitHub.com/mrJean1/PyGeodesy/issues/76>
         raise LazyAttributeError(_no_(_attribute_), txt=name)
 
 
+def _getmodinto(mod_DNAME, *Intos):
+    '''(INTERNAL) Core of C{_ALL_MODS.into}.
+    '''
+    _MODS = _ALL_MODS
+    mod, dun = _MODS.errors._xkwds_item2(mod_DNAME)
+    _mod = _UNDER_(NN, mod)
+    d = _MODS.getmodule(dun)  # '__main__' OK
+    i = _getmodattr(d, _mod, dun)
+    assert isinstance(i, Intos)
+    m = _MODS.getmodule(mod)
+    setattr(d, _mod, m)  # overwrite C{d._mod}
+    if isLazy > 1:
+        t = _SPACE_(_HASH_, _imported_, m.__name__)  # typename(m)
+        _hash_imported(t, _MODS.into.__name__)
+    assert getattr(d, _mod, None) is m
+    return m
+
+
 def _getmodule(name, *parent):
     '''(INTERNAL) Wrapper for C{import_module}.
     '''
@@ -614,6 +632,18 @@ def _getmodule(name, *parent):
         raise LazyImportError(_no_(_module_), txt=name)
 
 
+def _hash_imported(t, by_into, up=3):
+    '''(INTERNAL) Helper for C{_lazy_import2} and C{_ALL_MODS.into}.
+    '''
+    if isLazy > 2:
+        try:  # see C{internals._caller3}
+            _, f, s = _caller3(up)
+            t = _SPACE_(t, by_into, f, _line_, s)
+        except ValueError:
+            pass
+    printf(t)  # XXX print
+
+
 # def _lazy_attributes(DUNDER_name):
 #     '''(INTERNAL) Return a function to C{B{__name__}.__getattr__(attr)}
 #        on lazily imported modules and sub-modules.
@@ -666,7 +696,7 @@ def _lazy_import2(pack):  # MCCABE 14
     package, parent   = _lazy_init2(pack)  # _pygeodesy_
 
     _DPACKAGE_        = '__package__'
-    _lazily_imported_ = _SPACE_(_interns._HASH_, _lazily_, 'imported', parent)
+    _lazily_imported_ = _SPACE_(_HASH_, _lazily_, _imported_, parent)
 
     sub_packages =  set((parent, NN) + tuple(
                    _DOT_(parent, s) for s in _SUB_PACKAGES))
@@ -703,13 +733,7 @@ def _lazy_import2(pack):  # MCCABE 14
             t = _DOT_(_lazily_imported_, name)
             if mod and _tailof(mod) != name:
                 t = _SPACE_(t, _from_, _DOT_(NN, mod))
-            if isLazy > 2:
-                try:  # see C{_caller3}
-                    _, f, s = _caller3(2)
-                    t = _SPACE_(t, _by_, f, _line_, s)
-                except ValueError:
-                    pass
-            printf(t)  # XXX print
+            _hash_imported(t, _by_)
 
         return v  # __getattr__
 

pygeodesy/ltp.py

@@ -23,7 +23,7 @@ from pygeodesy.ecef import _EcefBase, EcefKarney, Ecef9Tuple, _llhn4, \
                            _xyzn4,  _WGS84
 from pygeodesy.errors import _NotImplementedError, _ValueError, _xattr, \
                              _xkwds, _xkwds_get, _xkwds_pop2
-from pygeodesy.fmath import fabs, fdot, fdot_, Fhorner
+from pygeodesy.fmath import fabs, fdot, Fdot_, fdot_, Fhorner
 from pygeodesy.fsums import _floor, fsumf_
 # from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import _0_, _COMMASPACE_, _DOT_, _ecef_, _height_, _M_, \
@@ -45,7 +45,7 @@ from pygeodesy.vector3d import _ALL_LAZY, Vector3d
 # from math import fabs, floor as _floor  # from .fmath, .fsums
 
 __all__ = _ALL_LAZY.ltp
-__version__ = '25.04.14'
+__version__ = '25.05.01'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -63,15 +63,18 @@ class Attitude(_NamedBase):
     def __init__(self, alt_attitude=INT0, tilt=INT0, yaw=INT0, roll=INT0, **name):
         '''New L{Attitude}.
 
-           @kwarg alt_attitude: Altitude (C{meter}) above earth or previous attitude
+           @kwarg alt_attitude: Altitude (C{meter}) above earth or a previous attitude
                       (L{Attitude} or L{Attitude4Tuple}) with the C{B{alt}itude},
                       B{C{tilt}}, B{C{yaw}} and B{C{roll}}.
            @kwarg tilt: Pitch, elevation from horizontal (C{degrees180}), negative down
-                        (clockwise rotation along and around the x- or East axis).
+                        (clockwise rotation along and around the x- or East axis), iff
+                        B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg yaw: Bearing, heading (compass C{degrees360}), clockwise from North
-                       (counter-clockwise rotation along and around the z- or Up axis).
+                       (counter-clockwise rotation along and around the z- or Up axis)
+                       iff B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg roll: Roll, bank (C{degrees180}), positive to the right and down
-                        (clockwise rotation along and around the y- or North axis).
+                        (clockwise rotation along and around the y- or North axis), iff
+                        B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg name: Optional C{B{name}=NN} C{str}).
 
            @raise AttitudeError: Invalid B{C{alt_attitude}}, B{C{tilt}}, B{C{yaw}} or
@@ -146,8 +149,10 @@ class Attitude(_NamedBase):
 
            @arg x_xyz: X component of vector (C{scalar}) or (3-D) vector (C{Cartesian},
                        L{Vector3d} or L{Vector3Tuple}).
-           @kwarg y: Y component of vector (C{scalar}), same units as B{C{x}}.
-           @kwarg z: Z component of vector (C{scalar}), same units as B{C{x}}.
+           @kwarg y: Y component of vector (C{scalar}), same units as C{scalar} B{C{x}},
+                     ignored otherwise.
+           @kwarg z: Z component of vector (C{scalar}), same units as C{sclar} B{C{x}},
+                     ignored otherwise.
            @kwarg Vector: Class to return transformed point (C{Cartesian}, L{Vector3d}
                           or C{Vector3Tuple}) or C{None}.
            @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
@@ -223,7 +228,7 @@ class Attitude(_NamedBase):
             _update_all(self)
             self._yaw = y
 
-    bearing = heading = yaw
+    bearing = heading = yaw  # azimuth
 
 
 class AttitudeError(_ValueError):
@@ -271,11 +276,14 @@ class Frustum(_NamedBase):
                               an attitude (L{Attitude} or L{Attitude4Tuple}) with the
                               C{B{alt}itude}, B{C{tilt}}, B{C{yaw}} and B{C{roll}}.
            @kwarg tilt: Pitch, elevation from horizontal (C{degrees}), negative down
-                        (clockwise rotation along and around the x- or East axis).
+                        (clockwise rotation along and around the x- or East axis) iff
+                        B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg yaw: Bearing, heading (compass C{degrees}), clockwise from North
-                       (counter-clockwise rotation along and around the z- or Up axis).
+                       (counter-clockwise rotation along and around the z- or Up axis)
+                       iff B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg roll: Roll, bank (C{degrees}), positive to the right and down
-                        (clockwise rotation along and around the y- or North axis).
+                        (clockwise rotation along and around the y- or North axis) iff
+                        B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg z: Optional height of the footprint (C{meter}) above I{local tangent plane}.
            @kwarg ltp: The I{local tangent plane} (L{Ltp}), overriding this
                        frustum's C{ltp}.
@@ -463,7 +471,7 @@ class LocalCartesian(_NamedBase):
         '''
         return self._ecef
 
-    def _ecef2local(self, ecef, Xyz, name_Xyz_kwds):
+    def _ecef2local(self, ecef, Xyz, name_Xyz_kwds):  # in _EcefLocal._Ltp_ecef2local
         '''(INTERNAL) Convert geocentric/geodetic to local, like I{forward}.
 
            @arg ecef: Geocentric (and geodetic) (L{Ecef9Tuple}).
@@ -504,10 +512,11 @@ class LocalCartesian(_NamedBase):
 
            @arg latlonh: Either a C{LatLon}, L{Ltp}, L{Ecef9Tuple} or C{scalar}
                          (geodetic) latitude (C{degrees}).
-           @kwarg lon: Optional C{scalar} (geodetic) longitude for C{scalar}
-                       B{C{latlonh}} (C{degrees}).
+           @kwarg lon: Optional C{scalar} (geodetic) longitude (C{degrees}) iff
+                       B{C{latlonh}} is C{scalar}, ignored otherwise.
            @kwarg height: Optional height (C{meter}, conventionally) perpendicular
-                          to and above (or below) the ellipsoid's surface.
+                          to and above (or below) the ellipsoid's surface, iff
+                          B{C{latlonh}} is C{scalar}, ignored othewrise.
            @kwarg M: Optionally, return the I{concatenated} rotation L{EcefMatrix},
                      iff available (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
@@ -591,7 +600,7 @@ class LocalCartesian(_NamedBase):
         return self._t0.M
 
     def reset(self, latlonh0=INT0, lon0=INT0, height0=INT0, ecef=None, **lon00_name):
-        '''Reset this converter, see L{LocalCartesian.__init__} for more details.
+        '''Reset this converter, see L{LocalCartesian.__init__} for further details.
         '''
         _, name = _xkwds_pop2(lon00_name, lon00=None)  # PYCHOK get **name
         if isinstance(latlonh0, LocalCartesian):
@@ -621,8 +630,10 @@ class LocalCartesian(_NamedBase):
 
            @arg xyz: A I{local} (L{XyzLocal}, L{Enu}, L{Ned}, L{Aer}, L{Local9Tuple}) or
                      local C{x} coordinate (C{scalar}).
-           @kwarg y: Local C{y} coordinate for C{scalar} B{C{xyz}} and B{C{z}} (C{meter}).
-           @kwarg z: Local C{z} coordinate for C{scalar} B{C{xyz}} and B{C{y}} (C{meter}).
+           @kwarg y: Local C{y} coordinate (C{meter}), iff B{C{xyz}} is C{scalar},
+                     ignored otherwise.
+           @kwarg z: Local C{z} coordinate (C{meter}), iff B{C{xyz}} is C{scalar},
+                     ignored otherwise.
            @kwarg M: Optionally, return the I{concatenated} rotation L{EcefMatrix}, iff
                      available (C{bool}).
            @kwarg lon00_name: Optional C{B{name}=NN} (C{str}) and keyword argument
@@ -734,18 +745,18 @@ class _ChLV(object):
         '''Convert WGS84 geodetic to I{Swiss} projection coordinates.  I{Must be overloaded}.
 
            @arg latlonh: Either a C{LatLon}, L{Ltp} or C{scalar} (geodetic) latitude (C{degrees}).
-           @kwarg lon: Optional, C{scalar} (geodetic) longitude for C{scalar} B{C{latlonh}} (C{degrees}).
+           @kwarg lon: Optional, C{scalar} (geodetic) longitude (C{degrees}) iff B{C{latlonh}} is
+                       C{scalar}, ignored otherwise.
            @kwarg height: Optional, height, vertically above (or below) the surface of the ellipsoid
-                          (C{meter}) for C{scalar} B{C{latlonh}} and B{C{lon}}.
+                          (C{meter}) iff B{C{latlonh}} and B{C{lon}} are C{scalar}, ignored otherwise.
            @kwarg M: If C{True}, return the I{concatenated} rotation L{EcefMatrix} iff available
-                     for C{ChLV} only, C{None} otherwise (C{bool}).
+                     and for C{ChLV} only, C{None} otherwise (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{ChLV9Tuple}C{(Y, X, h_, lat, lon, height, ltp, ecef, M)} with the unfalsed
                     I{Swiss Y, X} coordinates, I{Swiss h_} height, the given I{geodetic} C{lat},
-                    C{lon} and C{height}, this C{ChLV*} instance and C{ecef} (L{Ecef9Tuple}) at
-                    I{Bern, Ch} and rotation matrix C{M}.  The returned C{ltp} is this C{ChLV},
-                    C{ChLVa} or C{ChLVe} instance.
+                    C{lon} and C{height}, C{ecef} (L{Ecef9Tuple}) at I{Bern, Ch}, rotation matrix
+                    C{M} and C{ltp} this C{ChLV}, C{ChLVa} or C{ChLVe} instance.
 
            @raise LocalError: Invalid or non-C{scalar} B{C{latlonh}}, B{C{lon}} or B{C{height}}.
         '''
@@ -756,18 +767,18 @@ class _ChLV(object):
 
            @arg enh_: A Swiss projection (L{ChLV9Tuple}) or the C{scalar}, falsed I{Swiss E_LV95}
                      or I{y_LV03} easting (C{meter}).
-           @kwarg n: Falsed I{Swiss N_LV85} or I{x_LV03} northing for C{scalar} B{C{enh_}} and
-                     B{C{h_}} (C{meter}).
-           @kwarg h_: I{Swiss h'} height for C{scalar} B{C{enh_}} and B{C{n}} (C{meter}).
+           @kwarg n: Falsed I{Swiss N_LV85} or I{x_LV03} northing (C{meter}) iff B{C{enh_}} is
+                     C{scalar}, ignored otherwise.
+           @kwarg h_: I{Swiss h'} height (C{meter}) iff B{C{enh_}} and B{C{n}} are C{scalar},
+                      ignored otherwise.
            @kwarg M: If C{True}, return the I{concatenated} rotation L{EcefMatrix} iff available
-                     for C{ChLV} only, C{None} otherwise (C{bool}).
+                     and for C{ChLV} only, C{None} otherwise (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{ChLV9Tuple}C{(Y, X, h_, lat, lon, height, ltp, ecef, M)} with the unfalsed
                     I{Swiss Y, X} coordinates, I{Swiss h_} height, the given I{geodetic} C{lat},
-                    C{lon} and C{height}, this C{ChLV*} instance and C{ecef} (L{Ecef9Tuple}) at
-                    I{Bern, Ch} and rotation matrix C{M}.  The returned C{ltp} is this C{ChLV},
-                    C{ChLVa} or C{ChLVe} instance.
+                    C{lon} and C{height}, C{ecef} (L{Ecef9Tuple}) at I{Bern, Ch}, rotation matrix
+                    C{M} and C{ltp} this C{ChLV}, C{ChLVa} or C{ChLVe} instance.
 
            @raise LocalError: Invalid or non-C{scalar} B{C{enh_}}, B{C{n}} or B{C{h_}}.
         '''
@@ -818,7 +829,7 @@ class _ChLV(object):
     def _YXh_n4(self, enh_, n, h_, **name):
         '''(INTERNAL) Helper for C{ChLV*.reverse}.
         '''
-        Y, X, h_, name = _xyzn4(enh_, n, h_, ChLV9Tuple,
+        Y, X, h_, name = _xyzn4(enh_, n, h_, (ChLV9Tuple,),
                          _xyz_y_z_names=self._enh_n_h, **name)
         if isinstance(enh_, ChLV9Tuple):
             Y, X = enh_.Y, enh_.X
@@ -974,15 +985,15 @@ class ChLVa(_ChLV, LocalCartesian):
         a, b, h      = _ChLV._YXh_2abh3(Y, X, h_)
         ab_d, a2, b2 =  ChLV._ab_d, a**2, b**2
 
-        lat = fdot_(3.238272, b,
+        lat = Fdot_(3.238272, b,
                    -0.270978, a2,
                    -0.002528, b2,
                      -0.0447, a2 * b,
-                      -0.014, b2 * b, start=16.9023892) / ab_d
-        lon = fdot_(4.728982, a,
+                      -0.014, b2 * b, start=16.9023892).fover(ab_d)
+        lon = Fdot_(4.728982, a,
                     0.791484, a * b,
                       0.1306, a * b2,
-                     -0.0436, a * a2, start=2.6779094) / ab_d
+                     -0.0436, a * a2, start=2.6779094).fover(ab_d)
         return self._ChLV9Tuple(False, M, n, Y, X, h_, lat, lon, h)
 
 
@@ -997,8 +1008,8 @@ class ChLVe(_ChLV, LocalCartesian):
               argument C{B{gamma}=False} to approximate the I{meridian convergence}.
               If C{B{gamma}=True} a 2-tuple C{(t, gamma)} is returned with C{t} the
               usual result (C{ChLV9Tuple}) and C{gamma}, the I{meridian convergence}
-              (decimal C{degrees}).  To convert C{gamma} to C{grades} or C{gons},
-              use function L{pygeodesy.degrees2grades}.
+              (decimal C{degrees}).  To convert C{gamma} to C{grades} or C{gons}, use
+              function L{pygeodesy.degrees2grades}.
 
        @see: Older U{references<https://GitHub.com/alphasldiallo/Swisstopo-WGS84-LV03>}.
     '''
@@ -1070,20 +1081,6 @@ def _fov_2(**fov):
     raise LocalError(txt=t, **fov)
 
 
-def _toLocal(inst, ltp, Xyz, Xyz_kwds):
-    '''(INTERNAL) Helper for C{CartesianBase.toAer}, C{CartesianBase.toEnu},
-       C{CartesianBase.toLocal}, C{CartesianBase.toNed} and C{latLonBase.toLocal}.
-    '''
-    return _xLtp(ltp, inst._Ltp)._ecef2local(inst._ecef9, Xyz, Xyz_kwds)
-
-
-def _toLtp(inst, Ecef, ecef9, name):
-    '''(INTERNAL) Helper for C{CartesianBase.toLtp}, C{ecef.toLtp} and C{latLonBase.toLtp}.
-    '''
-    return inst._Ltp if (not name) and _isin(Ecef, None, inst.Ecef) else \
-                 Ltp(ecef9, ecef=Ecef(inst.datum), name=inst._name__(name))
-
-
 def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector_kwds):
     '''Convert an attitude pose into a (3-D) direction vector.
 

pygeodesy/ltpTuples.py

@@ -11,12 +11,13 @@ L{ChLVYX2Tuple}, L{ChLVyx2Tuple} and L{Footprint5Tuple}.
 @see: References in module L{ltp}.
 '''
 
-# from pygeodesy.basics import issubclassof  # _MODS
+from pygeodesy.basics import issubclassof,  typename
 from pygeodesy.constants import _0_0, _1_0, _90_0, _N_90_0
 # from pygeodesy.dms import F_D, toDMS  # _MODS
 from pygeodesy.errors import _TypeError, _TypesError, _xattr, _xkwds, \
                              _xkwds_item2
 from pygeodesy.fmath import fdot_, hypot, hypot_
+# rom pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _4_, _azimuth_, _center_, _COMMASPACE_, \
                              _ecef_, _elevation_, _height_, _lat_, _lon_, \
                              _ltp_, _M_, _name_, _up_, _X_, _x_, _xyz_, \
@@ -37,7 +38,7 @@ from pygeodesy.vector3d import Vector3d
 # from math import cos, radians  # from .utily
 
 __all__ = _ALL_LAZY.ltpTuples
-__version__ = '24.12.06'
+__version__ = '25.05.01'
 
 _aer_        = 'aer'
 _alt_        = 'alt'
@@ -48,6 +49,7 @@ _h__         = 'h_'
 _ned_        = 'ned'
 _north_      = 'north'
 _local_      = 'local'
+_ltp         = _MODS.into(ltp=__name__)
 _roll_       = 'roll'
 _slantrange_ = 'slantrange'
 _tilt_       = 'tilt'
@@ -158,25 +160,25 @@ class _Abc4Tuple(_NamedTuple):
     def _2Cls(self, Abc, Cls, Cls_kwds):
         '''(INTERNAL) Convert 4-Tuple to C{Cls} instance.
         '''
+        _isc =  issubclassof
         kwds = _name1__(Cls_kwds, _or_nameof=self)
-        _is  = _MODS.basics.issubclassof
         if Cls is None:
             n, _ = _name2__(Cls_kwds)
             r = self.copy(name=n) if n else self
-        elif _is(Cls, Abc):
+        elif _isc(Cls, Abc):
             r = Cls(*self, **kwds)
-        elif _is(Cls, Aer):
+        elif _isc(Cls, Aer):
             r = self.xyzLocal.toAer(**_xkwds(kwds, Aer=Cls))
-        elif _is(Cls, Enu):  # PYCHOK no cover
+        elif _isc(Cls, Enu):  # PYCHOK no cover
             r = self.xyzLocal.toEnu(**_xkwds(kwds, Enu=Cls))
-        elif _is(Cls, Ned):
+        elif _isc(Cls, Ned):
             r = self.xyzLocal.toNed(**_xkwds(kwds, Ned=Cls))
-        elif _is(Cls, XyzLocal):  # PYCHOK no cover
+        elif _isc(Cls, XyzLocal):  # PYCHOK no cover
             r = self.xyzLocal.toXyz(**_xkwds(kwds, Xyz=Cls))
         elif Cls is Local9Tuple:  # PYCHOK no cover
             r = self.xyzLocal.toLocal9Tuple(**kwds)
         else:  # PYCHOK no cover
-            n = Abc.__name__[:3]  # typename
+            n = typename(Abc)[:3]
             raise _TypesError(n, Cls, Aer, Enu, Ned, XyzLocal)
         return r
 
@@ -383,7 +385,7 @@ class Attitude4Tuple(_NamedTuple):
     def tyr3d(self):
         '''Get this attitude's (3-D) directional vector (L{Vector3d}).
         '''
-        return _MODS.ltp.Attitude(self).tyr3d
+        return _ltp.Attitude(self).tyr3d
 
 
 class Ned(_AbcBase):
@@ -731,7 +733,7 @@ class XyzLocal(_Vector3d):
     def _ltp_kwds_name3(self, ltp, kwds):
         '''(INTERNAL) Helper for methods C{toCartesian} and C{toLatLon}.
         '''
-        ltp  = _xLtp(ltp, self.ltp)
+        ltp  = _ltp._xLtp(ltp, self.ltp)
         kwds = _name1__(kwds, _or_nameof=self)
         kwds = _name1__(kwds, _or_nameof=ltp)
         return ltp, kwds, kwds.get(_name_, NN)
@@ -965,10 +967,11 @@ class Enu(XyzLocal):
                           I{local} instance (L{Enu}, L{Enu4Tuple}, L{Aer},
                           L{Aer4Tuple}, L{Local9Tuple}, L{Ned}, L{Ned4Tuple},
                           L{XyzLocal} or L{Xyz4Tuple}).
-           @kwarg north: Scalar North component (C{meter}) only used with
-                         scalar B{C{east_enu}}.
-           @kwarg up: Scalar Up component only used with scalar B{C{east_enu}},
-                      normal from the surface of the ellipsoid or sphere (C{meter}).
+           @kwarg north: Scalar North component (C{meter}), iff B{C{east_enu}}
+                         is C{meter}, ignored otherwise.
+           @kwarg up: Scalar Up component (C{meter}, normal from the surface
+                      of the ellipsoid or sphere), iff B{C{east_enu}} is
+                      C{meter}, ignored otherwise.
            @kwarg ltp: The I{local tangent plane}, (geodetic) origin (L{Ltp},
                        L{LocalCartesian}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
@@ -1249,10 +1252,12 @@ class Uvw(_Vector3d):
     def __init__(self, u_uvw, v=0, w=0, **name):
         '''New L{Uvw}.
 
-           @arg u_uvw: Scalar U component (C{meter}) or a previous instance
-                       (L{Uvw}, L{Uvw3Tuple}, L{Vector3d}).
-           @kwarg v: V component (C{meter}) only used with scalar B{C{u_uvw}}.
-           @kwarg w: W component (C{meter}) only used with scalar B{C{u_uvw}}.
+           @arg u_uvw: Scalar U component (C{meter}) or a previous instance (L{Uvw},
+                       L{Uvw3Tuple}, L{Vector3d}).
+           @kwarg v: V component (C{meter}), iff B{C{u_uvw}} is C{meter}, ignored
+                     otherwise.
+           @kwarg w: W component (C{meter}), iff B{C{u_uvw}} is C{meter}, ignored
+                     otherwise.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: Invalid B{C{east_enu}}.
@@ -1323,8 +1328,8 @@ class Los(Aer):
                              or a previous instance (L{Aer}, L{Aer4Tuple}, L{Enu},
                              L{Enu4Tuple} or L{Los}).
            @kwarg elevation: Scalar angle I{above} the horizon (C{degrees}, horizon
-                             is 0, zenith +90, nadir -90), only used with scalar
-                             B{C{azimuth_aer}}.
+                             is 0, zenith +90, nadir -90), if B{C{azimuth_aer}} is
+                             C{degrees}, ignored otherwise.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: Invalid B{C{azimuth_aer}}.
@@ -1388,19 +1393,19 @@ class ChLV9Tuple(Local9Tuple):
     def isChLV(self):
         '''Is this a L{ChLV}-generated L{ChLV9Tuple}?.
         '''
-        return self.ltp.__class__ is _MODS.ltp.ChLV
+        return self.ltp.__class__ is _ltp.ChLV
 
     @property_RO
     def isChLVa(self):
         '''Is this a L{ChLVa}-generated L{ChLV9Tuple}?.
         '''
-        return self.ltp.__class__ is _MODS.ltp.ChLVa
+        return self.ltp.__class__ is _ltp.ChLVa
 
     @property_RO
     def isChLVe(self):
         '''Is this a L{ChLVe}-generated L{ChLV9Tuple}?.
         '''
-        return self.ltp.__class__ is _MODS.ltp.ChLVe
+        return self.ltp.__class__ is _ltp.ChLVe
 
     @Property_RO
     def N_LV95(self):
@@ -1526,7 +1531,7 @@ class Footprint5Tuple(_NamedTuple):
 
            @see: Methods L{XyzLocal.toLatLon} and L{Footprint5Tuple.xyzLocal5}.
         '''
-        ltp  = _xLtp(ltp, self.center.ltp)  # PYCHOK .center
+        ltp  = _ltp._xLtp(ltp, self.center.ltp)  # PYCHOK .center
         kwds = _name1__(name_LatLon_kwds, _or_nameof=self)
         kwds = _xkwds(kwds, ltp=ltp, LatLon=LatLon)
         return Footprint5Tuple(t.toLatLon(**kwds) for t in self.xyzLocal5())
@@ -1544,7 +1549,7 @@ class Footprint5Tuple(_NamedTuple):
         if ltp is None:
             p =  self
         else:
-            p = _xLtp(ltp)
+            p = _ltp._xLtp(ltp)
             p =  tuple(Xyz4Tuple(t.x, t.y, t.z, p) for t in self)
         return Footprint5Tuple(t.xyzLocal for t in p)
 
@@ -1552,13 +1557,13 @@ class Footprint5Tuple(_NamedTuple):
 def _ChLV_false2(Y, X, **LV95_name):
     '''(INTERNAL) Invoke static method C{ltp.ChLV.false2}.
     '''
-    return _MODS.ltp.ChLV.false2(Y, X, **LV95_name)
+    return _ltp.ChLV.false2(Y, X, **LV95_name)
 
 
 def _ChLV_unfalse2(e, n, **LV95_name):
     '''(INTERNAL) Invoke static method C{ltp.ChLV.unfalse2}.
     '''
-    return _MODS.ltp.ChLV.unfalse2(e, n, **LV95_name)
+    return _ltp.ChLV.unfalse2(e, n, **LV95_name)
 
 
 def _er2gr(e, r):
@@ -1577,7 +1582,7 @@ def _init(inst, abc, ltp, name):
         n =  abc._name__(name)
         ltp = _xattr(abc, ltp=ltp)
     if ltp:
-        inst._ltp = _xLtp(ltp)
+        inst._ltp = _ltp._xLtp(ltp)
     if n:
         inst.name = n
 
@@ -1595,12 +1600,6 @@ def _toStr2(inst, prec=None, fmt=Fmt.SQUARE, sep=_COMMASPACE_):
     return a, t
 
 
-def _xLtp(ltp, *dflt):
-    '''(INTERNAL) Invoke C{ltp._xLtp}.
-    '''
-    return _MODS.ltp._xLtp(ltp, *dflt)
-
-
 def _xyz2aer4(inst):
     '''(INTERNAL) Convert C{(x, y, z}) to C{(A, E, R)}.
     '''