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

pygeodesy/auxilats/auxLat.py

@@ -13,7 +13,7 @@ under the MIT/X11 License.  For more information, see the U{GeographicLib
       U{On auxiliary latitudes<https://ArXiv.org/abs/2212.05818>}.
 '''
 # make sure int/int division yields float quotient, see .basics
-from __future__ import division as _; del _  # PYCHOK semicolon
+from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.auxilats.auxAngle import AuxAngle, AuxBeta, AuxChi, _AuxClass, \
                                         AuxMu, AuxPhi, AuxTheta, AuxXi
@@ -48,7 +48,7 @@ except ImportError:  # Python 3.11-
         return pow(_2_0, x)
 
 __all__ = ()
-__version__ = '25.04.14'
+__version__ = '25.05.12'
 
 _TRIPS = 1024  # XXX 2 or 3?
 

pygeodesy/auxilats/auxily.py

@@ -12,7 +12,7 @@ under the MIT/X11 License.  For more information, see the U{GeographicLib
 <https://GeographicLib.SourceForge.io>} documentation.
 '''
 # make sure int/int division yields float quotient, see .basics
-from __future__ import division as _; del _  # PYCHOK semicolon
+from __future__ import division as _; del _  # noqa: E702 ;
 
 # from pygeodesy import auxilats  # _MODS
 from pygeodesy.auxilats._CX_Rs import _Rkey
@@ -29,7 +29,7 @@ from pygeodesy.utily import atan1
 from math import asinh, copysign
 
 __all__ = ()
-__version__ = '25.04.14'
+__version__ = '25.05.12'
 
 
 class Aux(object):

pygeodesy/azimuthal.py

@@ -40,7 +40,7 @@ altitude in Earth radii<https://WikiPedia.org/wiki/Azimuthal_equidistant_project
 #/media/File:Comparison_azimuthal_projections.svg>}.
 '''
 # make sure int/int division yields float quotient, see .basics
-from __future__ import division as _; del _  # PYCHOK semicolon
+from __future__ import division as _; del _  # noqa: E702 ;
 
 # from pygeodesy.basics import _isin, _xinstanceof  # from .ellipsoidalBase
 from pygeodesy.constants import EPS, EPS0, EPS1, NAN, isnon0, _umod_360, \
@@ -71,7 +71,7 @@ from pygeodesy.utily import asin1, atan1, atan2, atan2b, atan2d, \
 from math import acos, degrees, fabs, sin, sqrt
 
 __all__ = _ALL_LAZY.azimuthal
-__version__ = '25.04.14'
+__version__ = '25.05.12'
 
 _EPS_K         = _EPStol * _0_1  # Karney's eps_ or _EPSmin * _0_1?
 _over_horizon_ = 'over horizon'

pygeodesy/basics.py

@@ -616,7 +616,7 @@ def map1(fun1, *xs):  # XXX map_
 
        @return: Function results (C{tuple}).
     '''
-    return tuple(map(fun1, xs))
+    return tuple(map(fun1, xs))  # if len(xs) != 1 else fun1(xs[0])
 
 
 def map2(fun, *xs, **strict):

pygeodesy/booleans.py

@@ -15,14 +15,14 @@ C{reverse-difference}, C{sum} and C{union}.
       <http://www.Inf.USI.CH/hormann/papers/Greiner.1998.ECO.pdf>}.
 '''
 # make sure int/int division yields float quotient, see .basics
-from __future__ import division as _; del _  # PYCHOK semicolon
+from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _isin, isodd, issubclassof, map2, \
                              _xscalar,  typename
 from pygeodesy.constants import EPS, EPS2, INT0, _0_0, _0_5, _1_0
 from pygeodesy.errors import ClipError, _IsnotError, _TypeError, \
                             _ValueError, _xattr, _xkwds_get, _xkwds_pop2
-from pygeodesy.fmath import favg, fdot_, hypot, hypot2
+from pygeodesy.fmath import favg, Fdot_, fdot_, hypot, hypot2
 # from pygeodesy.fsums import fsum1  # _MODS
 # from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _BANG_, _clipid_, _COMMASPACE_, \
@@ -45,7 +45,7 @@ from pygeodesy.utily import fabs, _unrollon, _Wrap
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.booleans
-__version__ = '25.04.14'
+__version__ = '25.05.12'
 
 _0EPS  =  EPS  # near-zero, positive
 _EPS0  = -EPS  # near-zero, negative
@@ -1612,8 +1612,8 @@ class _EdgeGH(object):
 
     def _alpha2(self, x, y, dx, dy):
         # Return C{(alpha)}, see .points.nearestOn5
-        a = fdot_(y, dy,  x, dx) / self._hypot2
-        d = fdot_(y, dx, -x, dy) / self._hypot0
+        a = Fdot_(y, dy,  x, dx).fover(self._hypot2)
+        d = Fdot_(y, dx, -x, dy).fover(self._hypot0)
         return a, fabs(d)
 
     def _Error(self, n, *args, **kwds):  # PYCHOK no cover
@@ -1655,10 +1655,10 @@ class _EdgeGH(object):
             if fabs(d) > _0EPS:  # non-parallel edges
                 dx = x - c1_x
                 dy = y - c1_y
-                ca = fdot_(sx, dy, -sy, dx) / d
+                ca = Fdot_(sx, dy, -sy, dx).fover(d)
                 if _0EPS < ca < _EPS1 or (self._xtend and
                    _EPS0 < ca < _1EPS):
-                    sa = fdot_(cx, dy, -cy, dx) / d
+                    sa = Fdot_(cx, dy, -cy, dx).fover(d)
                     if _0EPS < sa < _EPS1 or (self._xtend and
                        _EPS0 < sa < _1EPS):
                         yield (y + sa * sy), (x + sa * sx), sa, ca
@@ -1669,7 +1669,7 @@ class _EdgeGH(object):
 
                 elif self._raiser and not (ca < _EPS0 or ca > _1EPS):  # PYCHOK no cover
                     # intersection at c1 or c2 or at c1 or c2 and s1 or s2
-                    sa = fdot_(cx, dy, -cy, dx) / d
+                    sa = Fdot_(cx, dy, -cy, dx).fover(d)
                     e  = 2 if sa < _EPS0 or sa > _1EPS else 3
                     raise self._Error(e, c1, c2, ca=ca)
 

pygeodesy/cartesianBase.py

@@ -16,6 +16,7 @@ from pygeodesy.constants import EPS, EPS0, INT0, PI2, _isfinite, isnear0, \
 from pygeodesy.datums import Datum, _earth_ellipsoid, _spherical_datum, \
                              Transform, _WGS84
 # from pygeodesy.ecef import EcefKarney  # _MODS
+from pygeodesy.ecefLocals import _EcefLocal
 from pygeodesy.errors import _IsnotError, _TypeError, _ValueError, _xattr, \
                              _xdatum, _xkwds, _xkwds_get, _xkwds_pop2
 from pygeodesy.fmath import cbrt, hypot, hypot_, hypot2,  fabs, sqrt  # hypot
@@ -25,9 +26,9 @@ from pygeodesy.fsums import fsumf_,  Fmt
 from pygeodesy.interns import _COMMASPACE_, _datum_, _no_, _phi_
 from pygeodesy.interns import _ellipsoidal_, _spherical_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _name2__, _NamedLocal, _Pass
+from pygeodesy.named import _name2__, _Pass
 from pygeodesy.namedTuples import LatLon4Tuple, _NamedTupleTo , Vector3Tuple, \
-                                  Vector4Tuple,  Bearing2Tuple  # PYCHOK .sphericalBase
+                                  Vector4Tuple
 # from pygeodesy.nvectorBase import _N_vector  # _MODS
 from pygeodesy.props import deprecated_method, Property, Property_RO, property_doc_, \
                             property_RO, _update_all
@@ -43,14 +44,14 @@ from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 # from math import degrees, fabs, radians, sqrt  # from .fmath, .utily
 
 __all__ = _ALL_LAZY.cartesianBase
-__version__ = '25.04.21'
+__version__ = '25.05.07'
 
 _r_         = 'r'
 _resections = _MODS.into(resections=__name__)
 _theta_     = 'theta'
 
 
-class CartesianBase(Vector3d, _NamedLocal):
+class CartesianBase(Vector3d, _EcefLocal):
     '''(INTERNAL) Base class for ellipsoidal and spherical C{Cartesian}.
     '''
     _datum  = None  # L{Datum}, to be overriden
@@ -200,7 +201,7 @@ class CartesianBase(Vector3d, _NamedLocal):
         '''
         n, kwds = _name2__(name_Cartesian_kwds, _or_nameof=self)
         if Cartesian is None:
-            r = self._Ltp._local2ecef(delta, nine=True)
+            r = self._ltp._local2ecef(delta, nine=True)  # _EcefLocal._ltp
         else:
             d = self.datum
             if not d:
@@ -208,7 +209,7 @@ class CartesianBase(Vector3d, _NamedLocal):
             t = _xkwds_get(kwds, datum=d)
             if _xattr(t, ellipsoid=None) != d.ellipsoid:
                 raise _TypeError(datum=t, txt=str(d))
-            c = self._Ltp._local2ecef(delta, nine=False)
+            c = self._ltp._local2ecef(delta, nine=False)  # _EcefLocal._ltp
             r = Cartesian(*c, **kwds)
         return r.renamed(n) if n else r
 

pygeodesy/clipy.py

@@ -10,7 +10,7 @@ I{Greiner-Hormann} and L{clipSH} and L{clipSH3} I{Sutherland-Hodgeman}.
 .
 '''
 # make sure int/int division yields float quotient, see .basics
-from __future__ import division as _; del _  # PYCHOK semicolon
+from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import len2,  typename
 from pygeodesy.constants import EPS, _0_0, _1_0
@@ -31,7 +31,7 @@ from pygeodesy.units import Bool, FIx, HeightX, Lat, Lon, Number_
 # from math import fabs  # from .fmath
 
 __all__ = _ALL_LAZY.clipy
-__version__ = '25.04.14'
+__version__ = '25.05.12'
 
 _fj_       = 'fj'
 _original_ = 'original'

pygeodesy/constants.py

@@ -8,7 +8,7 @@ L{pygeodesy.isnear1}, L{pygeodesy.isnear90}, L{pygeodesy.isneg0}, L{pygeodesy.is
 L{pygeodesy.isnon0} and L{pygeodesy.remainder}.
 '''
 # make sure int/int division yields float quotient, see .basics
-from __future__ import division as _; del _  # PYCHOK semicolon
+from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _copysign, isbool, iscomplex, isint
 from pygeodesy.errors import _xError, _xError2, _xkwds_get1, _xkwds_item2
@@ -26,7 +26,7 @@ except ImportError:  # Python 2-
     _inf, _nan = float(_INF_), float(_NAN_)
 
 __all__ = _ALL_LAZY.constants
-__version__ = '25.04.14'
+__version__ = '25.05.12'
 
 
 def _copysign_0_0(y):

pygeodesy/datums.py

@@ -65,7 +65,7 @@ datum, q.v. U{"A Guide to Coordinate Systems in Great Britain", Section 6
 @var Transforms.WGS84: Transform(name='WGS84', tx=0.0, ty=0.0, tz=0.0, s1=1.0, rx=0.0, ry=0.0, rz=0.0, s=0.0, sx=0.0, sy=0.0, sz=0.0)
 '''
 # make sure int/int division yields float quotient, see .basics
-from __future__ import division as _; del _  # PYCHOK semicolon
+from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _isin, islistuple, map2, neg, _xinstanceof, _zip
 from pygeodesy.constants import R_M, _float as _F, _0_0, _1_0, _2_0, _8_0, _3600_0
@@ -94,7 +94,7 @@ from pygeodesy.units import _isRadius, Radius_,  radians
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.datums
-__version__ = '25.04.14'
+__version__ = '25.05.12'
 
 _a_ellipsoid_ = _UNDER_(_a_, _ellipsoid_)
 _BD72_        = 'BD72'

pygeodesy/deprecated/__init__.py

@@ -10,13 +10,13 @@ bases} or C{from pygeodesy.deprecated import bases}.  Likewise for C{datum} and
 C{nvector}.
 '''
 
-from pygeodesy.deprecated.bases import *  # PYCHOK not pygeodesy.__init__
-from pygeodesy.deprecated.datum import *  # PYCHOK not pygeodesy.__init__
-from pygeodesy.deprecated.nvector import *  # PYCHOK not pygeodesy.__init__
+from pygeodesy.deprecated.bases import *  # noqa: F403 not pygeodesy.__init__
+from pygeodesy.deprecated.datum import *  # noqa: F403 not pygeodesy.__init__
+from pygeodesy.deprecated.nvector import *  # noqa: F403 not pygeodesy.__init__
 
-from pygeodesy.deprecated.classes import *  # PYCHOK expected
-from pygeodesy.deprecated.consterns import *  # PYCHOK expected
-from pygeodesy.deprecated.functions import *  # PYCHOK expected
+from pygeodesy.deprecated.classes import *  # noqa: F403
+from pygeodesy.deprecated.consterns import *  # noqa: F403
+from pygeodesy.deprecated.functions import *  # noqa: F403
 
 from pygeodesy.lazily import _ALL_ATTRS, _ALL_DEPRECATED, _lazy_import_as, _unLazy0  # _lazy_import_star
 
@@ -27,11 +27,11 @@ __all__ = (_ALL_DEPRECATED.deprecated_bases +
            _ALL_DEPRECATED.deprecated_classes +
            _ALL_DEPRECATED.deprecated_consterns +
            _ALL_DEPRECATED.deprecated_functions)
-__version__ = '24.12.31'
+__version__ = '25.05.12'
 
 if _unLazy0:
     from pygeodesy.deprecated import bases, datum, nvector, rhumbBase, \
-                                     rhumbaux, rhumbsolve, rhumbx  # PYCHOK expected
+                                     rhumbaux, rhumbsolve, rhumbx  # noqa: F401 PYCHOK expected
     __all__ += _ALL_ATTRS(_ALL_DEPRECATED.deprecated)  # DEPRECATED modules
 
 else:  # lazily import modules and exported attrs

pygeodesy/deprecated/bases.py

@@ -4,12 +4,12 @@
 u'''DEPRECATED on 2021.02.10, use (INTERNAL) module L{pygeodesy.latlonBase} instead.
 '''
 
-from pygeodesy.iters import points2  # PYCHOK exported
+from pygeodesy.iters import points2  # noqa: F401
 from pygeodesy.latlonBase import LatLonBase as _LatLonBase
 from pygeodesy.lazily import _ALL_DEPRECATED
 
 __all__ = _ALL_DEPRECATED.deprecated_bases
-__version__ = '25.04.09'
+__version__ = '25.05.12'
 
 
 class LatLonHeightBase(_LatLonBase):  # PYCHOK no cover

pygeodesy/deprecated/rhumbBase.py

@@ -4,10 +4,10 @@
 u'''DEPRECATED on 2023.11.26, use module L{pygeodesy.rhumb.bases} instead.
 '''
 
-from pygeodesy.rhumb.bases import *  # PYCHOK expected
+from pygeodesy.rhumb.bases import *  # noqa: F403
 
 __all__ = ()  # _ALL_LAZY.rhumb._bases
-__version__ = '23.11.26'
+__version__ = '25.05.12'
 
 # **) MIT License
 #

pygeodesy/deprecated/rhumbaux.py

@@ -4,11 +4,11 @@
 u'''DEPRECATED on 2023.11.26, use module L{pygeodesy.rhumb.aux_} instead.
 '''
 
-from pygeodesy.rhumb.aux_ import *  # PYCHOK expected
+from pygeodesy.rhumb.aux_ import *  # noqa: F403
 from pygeodesy.lazily import _ALL_LAZY
 
 __all__ = _ALL_LAZY.rhumb_aux_  # attrs NOT DEPRECATED
-__version__ = '23.12.02'
+__version__ = '25.05.12'
 
 # **) MIT License
 #

pygeodesy/deprecated/rhumbsolve.py

@@ -4,11 +4,11 @@
 u'''DEPRECATED on 2023.11.26, use module L{pygeodesy.rhumb.solve} instead.
 '''
 
-from pygeodesy.rhumb.solve import *  # PYCHOK expected
+from pygeodesy.rhumb.solve import *  # noqa: F403
 from pygeodesy.lazily import _ALL_LAZY
 
 __all__ = _ALL_LAZY.rhumb_solve  # attrs NOT DEPRECATED
-__version__ = '23.11.26'
+__version__ = '25.05.12'
 
 # **) MIT License
 #

pygeodesy/deprecated/rhumbx.py

@@ -4,11 +4,11 @@
 u'''DEPRECATED on 2023.11.26, use module L{pygeodesy.rhumb.ekx} instead.
 '''
 
-from pygeodesy.rhumb.ekx import *  # PYCHOK expected
+from pygeodesy.rhumb.ekx import *  # noqa: F403
 from pygeodesy.lazily import _ALL_LAZY
 
 __all__ = _ALL_LAZY.rhumb_ekx  # attrs NOT DEPRECATED
-__version__ = '23.11.30'
+__version__ = '25.05.12'
 
 # **) MIT License
 #

pygeodesy/ecef.py

@@ -60,22 +60,21 @@ plane} as opposed to I{geocentric} (ECEF) ones.
 from pygeodesy.basics import copysign0, _isin, isscalar, issubclassof, neg, map1, \
                             _xinstanceof, _xsubclassof,  typename  # _args_kwds_names
 from pygeodesy.constants import EPS, EPS0, EPS02, EPS1, EPS2, EPS_2, INT0, PI, PI_2, \
-                               _0_0, _0_0001, _0_01, _0_5, _1_0, _1_0_1T, _N_1_0, \
-                               _2_0, _N_2_0, _3_0, _4_0, _6_0, _60_0, _90_0, _N_90_0, \
-                               _100_0, _copysign_1_0,  isnon0  # PYCHOK used!
-from pygeodesy.datums import a_f2Tuple, _ellipsoidal_datum, _WGS84,  _EWGS84
+                               _0_0, _0_5, _1_0, _1_0_1T, _2_0, _N_2_0, _3_0, _4_0, \
+                               _6_0, _90_0, _N_90_0, _copysign_1_0,  isnon0  # PYCHOK used!
+from pygeodesy.datums import _ellipsoidal_datum, _WGS84,  a_f2Tuple, _EWGS84
+from pygeodesy.ecefLocals import _EcefLocal
 # from pygeodesy.ellipsoids import a_f2Tuple, _EWGS84  # from .datums
 from pygeodesy.errors import _IndexError, LenError, _ValueError, _TypesError, \
                              _xattr, _xdatum, _xkwds, _xkwds_get
-from pygeodesy.fmath import cbrt, fdot, Fpowers, hypot, hypot1, hypot2_, sqrt0
+from pygeodesy.fmath import cbrt, fdot, hypot, hypot1, hypot2_, sqrt0
 from pygeodesy.fsums import Fsum, fsumf_,  Fmt, unstr
 # from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _a_, _C_, _datum_, _ellipsoid_, _f_, _height_, \
                              _lat_, _lon_, _M_, _name_, _singular_, _SPACE_, \
                              _x_, _xyz_, _y_, _z_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _name__, _name1__, _NamedBase, _NamedLocal, \
-                            _NamedTuple, _Pass, _xnamed
+from pygeodesy.named import _name__, _name1__, _NamedBase, _NamedTuple, _Pass, _xnamed
 from pygeodesy.namedTuples import LatLon2Tuple, LatLon3Tuple, \
                                   PhiLam2Tuple, Vector3Tuple, Vector4Tuple
 from pygeodesy.props import deprecated_method, Property_RO, property_RO, \
@@ -90,7 +89,7 @@ from pygeodesy.utily import atan1, atan1d, atan2, atan2d, degrees90, degrees180,
 from math import cos, degrees, fabs, radians, sqrt
 
 __all__ = _ALL_LAZY.ecef
-__version__ = '25.04.24'
+__version__ = '25.05.07'
 
 _Ecef_    = 'Ecef'
 _prolate_ = 'prolate'
@@ -110,6 +109,7 @@ class _EcefBase(_NamedBase):
     '''
     _datum = _WGS84
     _E     = _EWGS84
+    _isYou =  False
     _lon00 =  INT0  # arbitrary, "polar" lon for LocalCartesian, Ltp
 
     def __init__(self, a_ellipsoid=_EWGS84, f=None, lon00=INT0, **name):
@@ -272,12 +272,6 @@ class _EcefBase(_NamedBase):
         return (Ecef9Tuple,  # overwrite property_ROver
                _MODS.vector3d.Vector3d)  # _MODS.cartesianBase.CartesianBase
 
-    @Property_RO
-    def _isYou(self):
-        '''(INTERNAL) Is this an C{EcefYou}?.
-        '''
-        return isinstance(self, EcefYou)
-
     @property
     def lon00(self):
         '''Get the I{"polar"} longitude (C{degrees}), see method C{reverse}.
@@ -790,6 +784,7 @@ class EcefYou(_EcefBase):
              11589/115114_9021_geod2ellip_final.pdf>} Studia Geophysica et Geodaetica, 2008, 52,
              pages 1-18 and U{PyMap3D <https://PyPI.org/project/pymap3d>}.
     '''
+    _isYou = True
 
     def __init__(self, a_ellipsoid=_EWGS84, f=None, **lon00_name):  # PYCHOK signature
         _EcefBase.__init__(self, a_ellipsoid, f=f, **lon00_name)  # inherited documentation
@@ -825,13 +820,14 @@ class EcefYou(_EcefBase):
                              ellipsoid is I{prolate}.
         '''
         x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **lon00_name)
+        q = hypot(x, y)  # R
 
         E = self.ellipsoid
         e, e2 = self._ee2
 
-        q = hypot(x, y)  # R
-        u = Fpowers(2, x, y, z) - e2
-        u = u.fadd_(hypot(u, e * z * _2_0)).fover(_2_0)
+        u  =  hypot2_(x, y, z) - e2
+        u +=  hypot(u, e * z * _2_0)
+        u *= _0_5
         if u > EPS02:
             u = sqrt(u)
             p = hypot(u, e)
@@ -1019,7 +1015,7 @@ class EcefMatrix(_NamedTuple):
         return xyz_
 
 
-class Ecef9Tuple(_NamedTuple, _NamedLocal):
+class Ecef9Tuple(_NamedTuple, _EcefLocal):
     '''9-Tuple C{(x, y, z, lat, lon, height, C, M, datum)} with I{geocentric} C{x},
        C{y} and C{z} plus I{geodetic} C{lat}, C{lon} and C{height}, case C{C} (see
        the C{Ecef*.reverse} methods) and optionally, rotation matrix C{M} (L{EcefMatrix})
@@ -1041,7 +1037,7 @@ class Ecef9Tuple(_NamedTuple, _NamedLocal):
         return self.toDatum(datum2)
 
     @property_RO
-    def _ecef9(self):
+    def _ecef9(self):  # in ._EcefLocal._Ltp_ecef2local
         return self
 
     @Property_RO
@@ -1103,13 +1099,6 @@ class Ecef9Tuple(_NamedTuple, _NamedLocal):
         '''
         return Lon(Vermeille=degrees(self.lamVermeille))
 
-    def _ltp_toLocal(self, ltp, Xyz_kwds, **Xyz):  # overloads C{_NamedLocal}'s
-        '''(INTERNAL) Invoke C{ltp._xLtp(ltp)._ecef2local}.
-        '''
-        Xyz_ = self._ltp_toLocal2(Xyz_kwds, **Xyz)  # in ._NamedLocal
-        ltp  = self._ltp._xLtp(ltp, self._Ltp)  # both in ._NamedLocal
-        return ltp._ecef2local(self, *Xyz_)
-
     @Property_RO
     def phi(self):
         '''Get the latitude in C{radians} (C{float}).

pygeodesy/ecefLocals.py

@@ -0,0 +1,186 @@
+
+# -*- coding: utf-8 -*-
+
+u'''(INTERNAL) ECEF to local coodinate conversions, separated from
+module C{ecef} to defer importing the latter into C{CartesianBase}
+and C{LatLonBase}.
+'''
+
+from pygeodesy.basics import _isin, _xsubclassof
+# from pygeodesy.ecef import EcefKarney  # _MODS
+from pygeodesy.errors import _xkwds_item2, _xkwds_pop2
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
+# from pygeodesy import ltp as _ltp  # _MODS.into
+# from pygeodesy import ltpTuples as _ltpTuples  # _MODS.into
+from pygeodesy.named import _Named, notOverloaded
+from pygeodesy.props import Property_RO, property_RO, property_ROver
+
+__all__ = _ALL_LAZY.ecefLocals
+__version__ = '25.04.28'
+
+_ltp       = _MODS.into(ltp=__name__)
+_ltpTuples = _MODS.into(ltpTuples=__name__)
+
+
+class _EcefLocal(_Named):
+    '''(INTERNAL) Base class for C{CartesianBase}, C{Ecef9Tuple} and
+       C{LatLonBase}, providing ECEF to local coordinate conversions.
+    '''
+
+    @property_ROver
+    def Ecef(self):
+        '''Get the ECEF I{class} (L{EcefKarney}), I{once}.
+        '''
+        return _MODS.ecef.EcefKarney
+
+    @property_RO
+    def _ecef9(self):
+        '''I{Must be overloaded}.'''
+        notOverloaded(self)
+
+    @property_RO
+    def _ecef9datum(self):
+        try:
+            d = self.datum  # PYCHOK C{CartesianBase}, ...
+        except AttributeError:
+            d = None
+        return d or self._ecef9.datum
+
+    @Property_RO
+    def _ltp(self):
+        '''(INTERNAL) Cache this instance' LTP (L{Ltp}).
+        '''
+        return _ltp.Ltp(self._ecef9, ecef=self.Ecef(self._ecef9datum), name=self.name)
+
+    def _ltp_ecef2local(self, ltp, Xyz_kwds, _None=None, **Xyz):  # in C{Ecef9Tuple}
+        '''(INTERNAL) Invoke C{_ltp._xLtp(ltp, self._ltp)._ecef2local}.
+        '''
+        C, _ = Xyz_ = _xkwds_pop2(Xyz_kwds, **Xyz)
+        if C is not _None:  # validate C, see .toLocal
+            n, X = _xkwds_item2(Xyz)
+            if X is not C:
+                _xsubclassof(X, **{n: C})
+        ltp = _ltp._xLtp(ltp, self._ltp)
+        return ltp._ecef2local(self._ecef9, *Xyz_)
+
+    def toAer(self, ltp=None, **Aer_and_kwds):
+        '''Convert this instance to I{local} I{Azimuth, Elevation, slant Range} (AER) components.
+
+           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
+                       instance' L{LTP<pygeodesy.ecefLocals._EcefLocal.toLtp>}.
+           @kwarg Aer_and_kwds: Optional AER class C{B{Aer}=}L{Aer<pygeodesy.ltpTuples.Aer>}
+                      to use and optionally, additional B{C{Aer}} keyword arguments.
+
+           @return: An B{C{Aer}} instance.
+
+           @raise TypeError: Invalid B{C{ltp}}.
+
+           @see: Method L{toLocal<pygeodesy.ecefLocals._EcefLocal.toLocal>}.
+        '''
+        return self._ltp_ecef2local(ltp, Aer_and_kwds, Aer=_ltpTuples.Aer)
+
+    def toEnu(self, ltp=None, **Enu_and_kwds):
+        '''Convert this instance to I{local} I{East, North, Up} (ENU) components.
+
+           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
+                       instance' L{LTP<pygeodesy.ecefLocals._EcefLocal.toLtp>}.
+           @kwarg Enu_and_kwds: Optional ENU class C{B{Enu}=}L{Enu<pygeodesy.ltpTuples.Enu>}
+                      to use and optionally, additional B{C{Enu}} keyword arguments.
+
+           @return: An B{C{Enu}} instance.
+
+           @raise TypeError: Invalid B{C{ltp}}.
+
+           @see: Method L{toLocal<pygeodesy.ecefLocals._EcefLocal.toLocal>}.
+        '''
+        return self._ltp_ecef2local(ltp, Enu_and_kwds, Enu=_ltpTuples.Enu)
+
+    def toLocal(self, Xyz=None, ltp=None, **Xyz_kwds):
+        '''Convert this instance to I{local} components in a I{local tangent plane} (LTP)
+
+           @kwarg Xyz: Optional I{local} components class (L{XyzLocal}, L{Aer}, L{Enu},
+                       L{Ned}) or C{None}.
+           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
+                       cartesian's L{LTP<pygeodesy.ecefLocals._EcefLocal.toLtp>}.
+           @kwarg Xyz_kwds: Optionally, additional B{C{Xyz}} keyword arguments, ignored
+                            if C{B{Xyz} is None}.
+
+           @return: An B{C{Xyz}} instance or a L{Local9Tuple}C{(x, y, z, lat, lon,
+                    height, ltp, ecef, M)} if C{B{Xyz} is None} (with C{M=None}).
+
+           @raise TypeError: Invalid B{C{ltp}}.
+        '''
+        return self._ltp_ecef2local(ltp, Xyz_kwds, Xyz=Xyz, _None=Xyz)
+
+    def toLtp(self, Ecef=None, **name):
+        '''Return the I{local tangent plane} (LTP) for this instance.
+
+           @kwarg Ecef: Optional ECEF I{class} (L{EcefKarney}, ... L{EcefYou}), overriding
+                        this instance' L{Ecef<pygeodesy.ecefLocals._EcefLocal.Ecef>}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
+
+           @return: An B{C{Ltp}} instance.
+        '''
+        if _isin(Ecef, None, self.Ecef) and not name:
+            ltp = self._ltp
+        else:  # like self._ltp
+            ecef = (Ecef if Ecef else self.Ecef)(self._ecef9datum)
+            ltp  = _ltp.Ltp(self._ecef9, ecef=ecef, name=self._name__(name))
+        return ltp
+
+    def toNed(self, ltp=None, **Ned_and_kwds):
+        '''Convert this instance to I{local} I{North, East, Down} (NED) components.
+
+           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
+                       instance' L{LTP<pygeodesy.ecefLocals._EcefLocal.toLtp>}.
+           @kwarg Ned_and_kwds: Optional NED class C{B{Ned}=}L{Ned<pygeodesy.ltpTuples.Ned>}
+                      to use and optionally, additional B{C{Ned}} keyword arguments.
+
+           @return: An B{C{Ned}} instance.
+
+           @raise TypeError: Invalid B{C{ltp}}.
+
+           @see: Method L{toLocal<pygeodesy.ecefLocals._EcefLocal.toLocal>}.
+        '''
+        return self._ltp_ecef2local(ltp, Ned_and_kwds, Ned=_ltpTuples.Ned)
+
+    def toXyz(self, ltp=None, **Xyz_and_kwds):
+        '''Convert this instance to I{local} I{X, Y, Z} (XYZ) components.
+
+           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
+                       instance' L{LTP<pygeodesy.ecefLocals._EcefLocal.toLtp>}.
+           @kwarg Xyz_and_kwds: Optional XYZ class C{B{Xyz}=}L{Xyz<pygeodesy.ltpTuples.XyzLocal>}
+                      to use and optionally, additional B{C{Xyz}} keyword arguments.
+
+           @return: An B{C{Xyz}} instance.
+
+           @raise TypeError: Invalid B{C{ltp}}.
+
+           @see: Method L{toLocal<pygeodesy.ecefLocals._EcefLocal.toLocal>}.
+        '''
+        return self._ltp_ecef2local(ltp, Xyz_and_kwds, Xyz=_ltpTuples.XyzLocal)
+
+
+__all__ += _ALL_DOCS(_EcefLocal)
+
+# **) MIT License
+#
+# Copyright (C) 2016-2025 -- mrJean1 at Gmail -- All Rights Reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.

pygeodesy/ellipsoidalBase.py

@@ -10,7 +10,7 @@ and published under the same MIT Licence**, see for example U{latlon-ellipsoidal
 <https://www.Movable-Type.co.UK/scripts/geodesy/docs/latlon-ellipsoidal.js.html>}.
 '''
 # make sure int/int division yields float quotient, see .basics
-from __future__ import division as _; del _  # PYCHOK semicolon
+from __future__ import division as _; del _  # noqa: E702 ;
 
 # from pygeodesy.azimuthal import EquidistantExact, EquidistantKarney  # _MODS
 from pygeodesy.basics import _isin, _xinstanceof
@@ -46,7 +46,7 @@ from pygeodesy.units import Epoch, _isDegrees, Radius_, _1mm as _TOL_M
 # from math import fabs  # from .latlonBase
 
 __all__ = _ALL_LAZY.ellipsoidalBase
-__version__ = '25.04.14'
+__version__ = '25.05.12'
 
 
 class CartesianEllipsoidalBase(CartesianBase):