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

pygeodesy/sphericalBase.py

@@ -21,18 +21,18 @@ from pygeodesy.datums import Datums, _earth_ellipsoid, _spherical_datum
 from pygeodesy.errors import IntersectionError, _ValueError, \
                             _xattr, _xError
 from pygeodesy.fmath import favg, fdot, hypot, sqrt_a
-from pygeodesy.interns import NN, _COMMA_, _concentric_, _datum_, \
-                             _distant_, _exceed_PI_radians_, _name_, \
-                             _near_, _radius_, _too_
+from pygeodesy.interns import _COMMA_, _concentric_, _datum_, _distant_, \
+                              _exceed_PI_radians_, _name_, _near_, \
+                              _radius_, _too_
 from pygeodesy.latlonBase import LatLonBase,  _trilaterate5  # PYCHOK passed
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.namedTuples import Bearing2Tuple  # from .cartesianBase
 from pygeodesy.nvectorBase import NvectorBase,  Fmt, _xattrs
-from pygeodesy.props import deprecated_method, property_doc_, \
-                            property_RO, _update_all
+from pygeodesy.props import deprecated_method, property_doc_, property_RO, \
+                           _update_all
 # from pygeodesy.streprs import Fmt, _xattrs  # from .nvectorBase
-from pygeodesy.units import _isRadius, Bearing, Bearing_, Radians_, \
-                             Radius, Radius_, Scalar_, _100km
+from pygeodesy.units import Bearing, Bearing_, _isRadius, Radians_, Radius, \
+                            Radius_, Scalar_, _100km
 from pygeodesy.utily import acos1, asin1, atan2b, atan2d, degrees90, \
                             degrees180, sincos2, sincos2d, _unrollon, \
                             tanPI_2_2, wrapPI
@@ -40,7 +40,7 @@ from pygeodesy.utily import acos1, asin1, atan2b, atan2d, degrees90, \
 from math import cos, fabs, log, sin, sqrt
 
 __all__ = _ALL_LAZY.sphericalBase
-__version__ = '23.12.18'
+__version__ = '24.06.06'
 
 
 class CartesianSphericalBase(CartesianBase):
@@ -117,7 +117,7 @@ class LatLonSphericalBase(LatLonBase):
     _datum       =  Datums.Sphere  # spherical L{Datum}
     _napieradius = _100km
 
-    def __init__(self, latlonh, lon=None, height=0, datum=None, wrap=False, name=NN):
+    def __init__(self, latlonh, lon=None, height=0, datum=None, wrap=False, **name):
         '''Create a spherical C{LatLon} point frome the given lat-, longitude and
            height on the given datum.
 
@@ -132,12 +132,12 @@ class LatLonSphericalBase(LatLonBase):
                          conventionally).
            @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}}
                         (C{bool}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: If B{C{latlonh}} is not a C{LatLon} or B{C{datum}} not
                              spherical.
         '''
-        LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, name=name)
+        LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, **name)
         if datum not in (None, self.datum):
             self.datum = datum
 
@@ -302,26 +302,22 @@ class LatLonSphericalBase(LatLonBase):
 #           raise _xError(x, this=self, point=point, other=other, **radius_exact_height_wrap)
 #       return p.midpointTo(q)
 
-    def parse(self, strllh, height=0, sep=_COMMA_, name=NN):
+    def parse(self, strllh, height=0, sep=_COMMA_, **name):
         '''Parse a string representing a similar, spherical C{LatLon}
            point, consisting of C{"lat, lon[, height]"}.
 
-           @arg strllh: Lat, lon and optional height (C{str}),
-                        see function L{pygeodesy.parse3llh}.
+           @arg strllh: Lat, lon and optional height (C{str}), see function
+                        L{pygeodesy.parse3llh}.
            @kwarg height: Optional, default height (C{meter}).
            @kwarg sep: Optional separator (C{str}).
-           @kwarg name: Optional instance name (C{str}),
-                        overriding this name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
 
            @return: The similar point (spherical C{LatLon}).
 
            @raise ParseError: Invalid B{C{strllh}}.
         '''
-        t = _MODS.dms.parse3llh(strllh, height=height, sep=sep)
-        r =  self.classof(*t)
-        if name:
-            r.rename(name)
-        return r
+        llh = _MODS.dms.parse3llh(strllh, height=height, sep=sep)
+        return self.classof(*llh, **name)
 
     @property_RO
     def _radius(self):
@@ -384,7 +380,8 @@ class LatLonSphericalBase(LatLonBase):
         '''DEPRECATED, use method C{.rhumbAzimuthTo}.'''
         return self.rhumbAzimuthTo(other, b360=True)  # [0..360)
 
-    def rhumbDestination(self, distance, azimuth, radius=R_M, height=None, exact=False):
+    def rhumbDestination(self, distance, azimuth, radius=R_M, height=None,
+                                                   exact=False, **name):
         '''Return the destination point having travelled the given distance from
            this point along a rhumb line (loxodrome) of the given azimuth.
 
@@ -397,6 +394,7 @@ class LatLonSphericalBase(LatLonBase):
            @kwarg height: Optional height, overriding the default height (C{meter}.
            @kwarg exact: If C{True}, use I{Elliptic, Krüger} L{Rhumb} (C{bool}),
                          default C{False} for backward compatibility.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: The destination point (spherical C{LatLon}).
 
@@ -405,7 +403,7 @@ class LatLonSphericalBase(LatLonBase):
         '''
         if exact:  # use series, always
             r = LatLonBase.rhumbDestination(self, distance, azimuth, exact=False,  # Krüger
-                                                  radius=radius, height=height)
+                                                  radius=radius, height=height, **name)
         else:  # radius=None from .rhumbMidpointTo
             if radius in (None, self._radius):
                 d, r = self.datum, radius
@@ -429,7 +427,7 @@ class LatLonSphericalBase(LatLonBase):
             b2 = b1 if isnear0(q) else (b1 + r * sb / q)
 
             h = self._heigHt(height)
-            r = self.classof(degrees90(a2), degrees180(b2), datum=d, height=h)
+            r = self.classof(degrees90(a2), degrees180(b2), datum=d, height=h, **name)
         return r
 
     def rhumbDistanceTo(self, other, radius=R_M, exact=False, wrap=False):
@@ -503,7 +501,7 @@ class LatLonSphericalBase(LatLonBase):
                                              height=height, wrap=wrap)
 
     def rhumbMidpointTo(self, other, height=None, radius=R_M, exact=False,
-                                                fraction=_0_5, wrap=False):
+                                                fraction=_0_5, **wrap_name):
         '''Return the (loxodromic) midpoint on the rhumb line between
            this and an other point.
 
@@ -515,8 +513,9 @@ class LatLonSphericalBase(LatLonBase):
                          default C{False} for backward compatibility.
            @kwarg fraction: Midpoint location from this point (C{scalar}), may
                             be negative if C{B{exact}=True}.
-           @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{other}}
-                        point (C{bool}).
+           @kwarg wrap_name: Optional C{B{name}=NN} (C{str}) and optional keyword
+                       argument C{B{wrap}=False}, if C{True}, wrap or I{normalize}
+                       and unroll the B{C{other}} point (C{bool}).
 
            @return: The (mid)point at the given B{C{fraction}} along the rhumb
                     line (spherical C{LatLon}).
@@ -528,18 +527,21 @@ class LatLonSphericalBase(LatLonBase):
         if exact:  # use series, always
             r = LatLonBase.rhumbMidpointTo(self, other, exact=False,  # Krüger
                                                  radius=radius, height=height,
-                                                 fraction=fraction, wrap=wrap)
+                                                 fraction=fraction, **wrap_name)
         elif fraction is not _0_5:
             f = Scalar_(fraction=fraction)  # low=_0_0
-            r, db, dp = self._rhumbs3(other, wrap, r=True)  # radians
+            w, n      = self._wrap_name2(**wrap_name)
+            r, db, dp = self._rhumbs3(other, w, r=True)  # radians
             z = atan2b(db, dp)
             h = self._havg(other, f=f, h=height)
-            r = self.rhumbDestination(r * f, z, radius=None, height=h)
+            r = self.rhumbDestination(r * f, z, radius=None, height=h, name=n)
 
         else:  # for backward compatibility, unwrapped
+            _,  n  = self._wrap_name2(**wrap_name)
             # see <https://MathForum.org/library/drmath/view/51822.html>
             a1, b1 = self.philam
             a2, b2 = self.others(other).philam
+            _,  n  = self._wrap_name2(**wrap_name)
 
             if fabs(b2 - b1) > PI:
                 b1 += PI2  # crossing anti-meridian
@@ -561,7 +563,7 @@ class LatLonSphericalBase(LatLonBase):
             d = self.datum if radius in (None, self._radius) else \
                _spherical_datum(radius, name=self.name, raiser=_radius_)
             h = self._havg(other, h=height)
-            r = self.classof(degrees90(a3), degrees180(b3), datum=d, height=h)
+            r = self.classof(degrees90(a3), degrees180(b3), datum=d, height=h, name=n)
         return r
 
     @property_RO

pygeodesy/sphericalTrigonometry.py

@@ -54,7 +54,7 @@ from pygeodesy.vector3d import sumOf, Vector3d
 from math import asin, atan2, cos, degrees, fabs, radians, sin
 
 __all__ = _ALL_LAZY.sphericalTrigonometry
-__version__ = '24.045.19'
+__version__ = '24.05.25'
 
 _PI_EPS4 = PI - EPS4
 if _PI_EPS4 >= PI:
@@ -538,7 +538,7 @@ class LatLon(LatLonSphericalBase):
     def nearestOn(self, point1, point2, radius=R_M, **wrap_adjust_limit):
         '''Locate the point between two points closest to this point.
 
-           Distances are approximated by function L{pygeodesy.equirectangular_},
+           Distances are approximated by function L{pygeodesy.equirectangular4},
            subject to the supplied B{C{options}}.
 
            @arg point1: Start point (L{LatLon}).
@@ -546,12 +546,12 @@ class LatLon(LatLonSphericalBase):
            @kwarg radius: Mean earth radius (C{meter}).
            @kwarg wrap_adjust_limit: Optional keyword arguments for functions
                               L{sphericalTrigonometry.nearestOn3} and
-                              L{pygeodesy.equirectangular_},
+                              L{pygeodesy.equirectangular4},
 
            @return: Closest point on the great circle line (L{LatLon}).
 
            @raise LimitError: Lat- and/or longitudinal delta exceeds B{C{limit}},
-                              see function L{pygeodesy.equirectangular_}.
+                              see function L{pygeodesy.equirectangular4}.
 
            @raise NotImplementedError: Keyword argument C{B{within}=False}
                                        is not (yet) supported.
@@ -560,7 +560,7 @@ class LatLon(LatLonSphericalBase):
 
            @raise ValueError: Invalid B{C{radius}} or B{C{options}}.
 
-           @see: Functions L{pygeodesy.equirectangular_} and L{pygeodesy.nearestOn5}
+           @see: Functions L{pygeodesy.equirectangular4} and L{pygeodesy.nearestOn5}
                  and method L{sphericalTrigonometry.LatLon.nearestOn3}.
         '''
         # remove kwarg B{C{within}} if present
@@ -605,7 +605,7 @@ class LatLon(LatLonSphericalBase):
     def nearestOn3(self, points, closed=False, radius=R_M, **wrap_adjust_limit):
         '''Locate the point on a polygon closest to this point.
 
-           Distances are approximated by function L{pygeodesy.equirectangular_},
+           Distances are approximated by function L{pygeodesy.equirectangular4},
            subject to the supplied B{C{options}}.
 
            @arg points: The polygon points (L{LatLon}[]).
@@ -613,17 +613,17 @@ class LatLon(LatLonSphericalBase):
            @kwarg radius: Mean earth radius (C{meter}).
            @kwarg wrap_adjust_limit: Optional keyword arguments for function
                               L{sphericalTrigonometry.nearestOn3} and
-                              L{pygeodesy.equirectangular_},
+                              L{pygeodesy.equirectangular4},
 
            @return: A L{NearestOn3Tuple}C{(closest, distance, angle)} of the
-                    C{closest} point (L{LatLon}), the L{pygeodesy.equirectangular_}
+                    C{closest} point (L{LatLon}), the L{pygeodesy.equirectangular4}
                     C{distance} between this and the C{closest} point converted to
                     C{meter}, same units as B{C{radius}}.  The C{angle} from this
                     to the C{closest} point is in compass C{degrees360}, like
                     function L{pygeodesy.compassAngle}.
 
            @raise LimitError: Lat- and/or longitudinal delta exceeds B{C{limit}},
-                              see function L{pygeodesy.equirectangular_}.
+                              see function L{pygeodesy.equirectangular4}.
 
            @raise PointsError: Insufficient number of B{C{points}}.
 
@@ -631,7 +631,7 @@ class LatLon(LatLonSphericalBase):
 
            @raise ValueError: Invalid B{C{radius}} or B{C{options}}.
 
-           @see: Functions L{pygeodesy.compassAngle}, L{pygeodesy.equirectangular_}
+           @see: Functions L{pygeodesy.compassAngle}, L{pygeodesy.equirectangular4}
                  and L{pygeodesy.nearestOn5}.
         '''
         return nearestOn3(self, points, closed=closed, radius=radius,
@@ -1222,7 +1222,7 @@ def nearestOn3(point, points, closed=False, radius=R_M, wrap=False, adjust=True,
                                                         limit=9, **LatLon_and_kwds):
     '''Locate the point on a path or polygon closest to a reference point.
 
-       Distances are I{approximated} using function L{pygeodesy.equirectangular_},
+       Distances are I{approximated} using function L{pygeodesy.equirectangular4},
        subject to the supplied B{C{options}}.
 
        @arg point: The reference point (L{LatLon}).
@@ -1231,19 +1231,19 @@ def nearestOn3(point, points, closed=False, radius=R_M, wrap=False, adjust=True,
        @kwarg radius: Mean earth radius (C{meter}).
        @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
                     B{C{points}} (C{bool}).
-       @kwarg adjust: See function L{pygeodesy.equirectangular_} (C{bool}).
-       @kwarg limit: See function L{pygeodesy.equirectangular_} (C{degrees}),
+       @kwarg adjust: See function L{pygeodesy.equirectangular4} (C{bool}).
+       @kwarg limit: See function L{pygeodesy.equirectangular4} (C{degrees}),
                      default C{9 degrees} is about C{1,000 Kmeter} (for mean
                      spherical earth radius L{R_KM}).
        @kwarg LatLon: Optional class to return the closest point (L{LatLon})
                       or C{None}.
        @kwarg options: Optional keyword arguments for function
-                       L{pygeodesy.equirectangular_}.
+                       L{pygeodesy.equirectangular4}.
 
        @return: A L{NearestOn3Tuple}C{(closest, distance, angle)} with the
                 C{closest} point as B{C{LatLon}} or L{LatLon3Tuple}C{(lat,
                 lon, height)} if B{C{LatLon}} is C{None}.  The C{distance}
-                is the L{pygeodesy.equirectangular_} distance between the
+                is the L{pygeodesy.equirectangular4} distance between the
                 C{closest} and the given B{C{point}} converted to C{meter},
                 same units as B{C{radius}}.  The C{angle} from the given
                 B{C{point}} to the C{closest} is in compass C{degrees360},
@@ -1251,7 +1251,7 @@ def nearestOn3(point, points, closed=False, radius=R_M, wrap=False, adjust=True,
                 the (interpolated) height at the C{closest} point.
 
        @raise LimitError: Lat- and/or longitudinal delta exceeds the B{C{limit}},
-                          see function L{pygeodesy.equirectangular_}.
+                          see function L{pygeodesy.equirectangular4}.
 
        @raise PointsError: Insufficient number of B{C{points}}.
 
@@ -1259,7 +1259,7 @@ def nearestOn3(point, points, closed=False, radius=R_M, wrap=False, adjust=True,
 
        @raise ValueError: Invalid B{C{radius}}.
 
-       @see: Functions L{pygeodesy.equirectangular_} and L{pygeodesy.nearestOn5}.
+       @see: Functions L{pygeodesy.equirectangular4} and L{pygeodesy.nearestOn5}.
     '''
     t = _nearestOn5(point, points, closed=closed, wrap=wrap,
                                    adjust=adjust, limit=limit)

pygeodesy/streprs.py

@@ -8,7 +8,7 @@ from pygeodesy.basics import isint, islistuple, isscalar, isstr, itemsorted, \
                             _zip, _0_0
 # from pygeodesy.constants import _0_0
 from pygeodesy.errors import _or, _AttributeError, _IsnotError, _TypeError, \
-                             _ValueError, _xkwds_get, _xkwds_item2, _xkwds_pop2
+                             _ValueError, _xkwds_get, _xkwds_item2
 # from pygeodesy.internals import _dunder_nameof  # from .lazily
 from pygeodesy.interns import NN, _0_, _0to9_, MISSING, _BAR_, _COMMASPACE_, \
                              _DOT_, _E_, _ELLIPSIS_, _EQUAL_, _H_, _LR_PAIRS, \
@@ -22,7 +22,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS,  _dunder_nameof
 from math import fabs, log10 as _log10
 
 __all__ = _ALL_LAZY.streprs
-__version__ = '24.05.19'
+__version__ = '24.06.04'
 
 _at_        = 'at'         # PYCHOK used!
 _EN_PREC    =  6           # max MGRS/OSGR precision, 1 micrometer
@@ -546,8 +546,10 @@ def unstr(where, *args, **kwds):
 
        @return: Representation (C{str}).
     '''
-    e, kwds = _xkwds_pop2(kwds, _ELLIPSIS=False)
-    g, kwds = _xkwds_pop2(kwds, _fmt=Fmt.g)
+    def _e_g_kwds3(_ELLIPSIS=False, _fmt=Fmt.g, **kwds):
+        return _ELLIPSIS, _fmt, kwds
+
+    e, g, kwds = _e_g_kwds3(**kwds)
     t = reprs(args, fmt=g) if args else ()
     if e:
         t += _ELLIPSIS_,

pygeodesy/trf.py

@@ -80,8 +80,8 @@ from pygeodesy.interns import MISSING, NN, _AT_, _COMMASPACE_, _conversion_, \
                              _NAD83_, _no_, _PLUS_, _reframe_, _s_, _SPACE_, \
                              _STAR_, _to_, _vs_, _WGS84_, _x_, _intern as _i
 # from pygeodesy.lazily import _ALL_LAZY  # from .units
-from pygeodesy.named import ADict, classname, _lazyNamedEnumItem as _lazy, _Named, \
-                           _NamedEnum, _NamedEnumItem, _NamedTuple,  Fmt, unstr
+from pygeodesy.named import ADict, classname, _lazyNamedEnumItem as _lazy, _name2__, \
+                           _Named, _NamedEnum, _NamedEnumItem, _NamedTuple,  Fmt, unstr
 from pygeodesy.props import deprecated_method, property_doc_, Property_RO, property_RO
 # from pygeodesy.streprs import Fmt, unstr  # from .named
 from pygeodesy.units import Epoch, Float,  _ALL_LAZY
@@ -91,7 +91,7 @@ from math import ceil as _ceil, fabs
 # import operator as _operator  # from .datums
 
 __all__ = _ALL_LAZY.trf
-__version__ = '24.05.21'
+__version__ = '24.06.09'
 
 _EP0CH    =  Epoch(0, low=0)
 _Es       = {_EP0CH: _EP0CH}  # L{Epoch}s, deleted below
@@ -253,7 +253,7 @@ class RefFrame(_NamedEnumItem):
         '''
         D = self.datum
         e = self.epoch if epoch is None else _Epoch(epoch)
-        t = (Fmt.EQUAL(name=repr(name or self.name)),
+        t = (Fmt.EQUAL(name=repr(self._name__(name))),
              Fmt.EQUAL(epoch=e),
              Fmt.EQUAL(datum=_DOT_(classname(D) + _s_, D.name)))
         return _COMMASPACE_.join(t[int(name is None):])
@@ -405,10 +405,11 @@ class TransformXform(Transform):
         n = name or (X.toStr() if X else NN)
         return Transform.rename(self, n)
 
-    def toRefFrame(self, point, name=NN):  # PYCHOK signature
+    def toRefFrame(self, point, **name):  # PYCHOK signature
         '''Convert an ellipsoidal point using this transform and Xform.
 
            @arg point: The point to convert (C{Cartesian} or C{LatLon}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A copy of the B{C{point}}, converted I{directly} to
                     this transform's Xform's C{refName2} and C{epoch}.
@@ -423,7 +424,7 @@ class TransformXform(Transform):
         if X:  # see _toRefFrame below
             p._reframe = X.reframe2
             p._epoch   = X.epoch
-        p.rename(name or self.name)
+        p.rename(self._name__(name))
         return p
 
     def toTransform(self, epoch1, **epoch2_inverse):
@@ -902,7 +903,7 @@ def date2epoch(year, month, day):
             e = y + float(sum(_mDays[:m]) + d) / _366_0
             return Epoch(e, low=0)
 
-        raise ValueError  # _invalid_
+        raise ValueError()  # _invalid_
     except (TRFError, TypeError, ValueError) as x:
         raise TRFError(year=year, month=month, day=day, cause=x)
 
@@ -1043,7 +1044,7 @@ def _sumstr(name1, name2, p_):
 
 
 def _toRefFrame(point, reframe2, reframe=None, epoch=None,
-                       epoch2=None, name=NN, **LatLon_kwds):
+                       epoch2=None, **name_LatLon_kwds):
     '''(INTERNAL) Convert an ellipsoidal point to C{reframe2}
        and C{epoch2 or epoch or pont.epoch or reframe.epoch}.
     '''
@@ -1063,6 +1064,7 @@ def _toRefFrame(point, reframe2, reframe=None, epoch=None,
                            _to_, _AT_(reframe2.name, e2))
         raise TRFError(_no_(_conversion_), txt=t)
 
+    name, LatLon_kwds = _name2__(name_LatLon_kwds)
     if t0:  # is not ()
         if t0.isunity:
             p = point.dup()
@@ -1078,7 +1080,7 @@ def _toRefFrame(point, reframe2, reframe=None, epoch=None,
             p = point.toTransform(t0)
         p._reframe =  reframe2  # see TRFXform.toRefFrame above
         p._epoch   = _xattr(t0.Xform, epoch=e2)
-        p.rename(name or reframe2.name)
+        p.rename(reframe2._name__(name))
     else:
         p = point.dup(_reframe=reframe2,  # ditto
                       _epoch=e2, name=name) if name else point

pygeodesy/triaxials.py

@@ -35,7 +35,6 @@ from pygeodesy.constants import EPS, EPS0, EPS02, EPS4, INT0, PI2, PI_3, PI4, \
                                _EPS2e4, float0_, isfinite, isnear1, _0_0, _0_5, \
                                _1_0, _N_1_0, _N_2_0,  _4_0  # PYCHOK used!
 from pygeodesy.datums import Datum, _spherical_datum, _WGS84,  Ellipsoid, _EWGS84, Fmt
-# from pygeodesy.dms import toDMS  # _MODS
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
 # from pygeodesy.elliptic import Elliptic  # _MODS
 # from pygeodesy.errors import _ValueError  # from .basics
@@ -47,38 +46,49 @@ from pygeodesy.interns import NN, _a_, _b_, _beta_, _c_, _distant_, _finite_, \
                              _spherical_, _too_, _x_, _y_
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .vector3d
 from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _NamedEnum, \
-                                _NamedEnumItem, _NamedTuple, _Pass
-from pygeodesy.namedTuples import LatLon3Tuple, Vector3Tuple, Vector4Tuple
+                                _NamedEnumItem, _Pass
+from pygeodesy.namedTuples import LatLon3Tuple, _NamedTupleTo, Vector3Tuple, \
+                                  Vector4Tuple
 from pygeodesy.props import Property_RO, property_RO
 # from pygeodesy.streprs import Fmt  # from .datums
-from pygeodesy.units import Float, Height_, Meter, Meter2, Meter3, Radians, \
-                            Radius, Scalar_, _toDegrees, _toRadians
+from pygeodesy.units import Degrees, Float, Height_, Meter, Meter2, Meter3, \
+                            Radians, Radius, Scalar_
 from pygeodesy.utily import asin1, atan2d, km2m, m2km, SinCos2, sincos2d_
 from pygeodesy.vector3d import _otherV3d, Vector3d,  _ALL_LAZY, _MODS
 
 from math import atan2, fabs, sqrt
 
 __all__ = _ALL_LAZY.triaxials
-__version__ = '24.05.21'
+__version__ = '24.06.09'
 
 _not_ordered_ = _not_('ordered')
 _omega_       = 'omega'
 _TRIPS        =  269  # 48-55, Eberly 1074?
 
 
-class _NamedTupleTo(_NamedTuple):  # in .testNamedTuples, like .cartesianBase.RadiusThetaPhi3Tuple
-    '''(INTERNAL) Base for C{-.toDegrees}, C{-.toRadians}.
+class _NamedTupleToX(_NamedTupleTo):  # in .testNamedTuples
+    '''(INTERNAL) Base class for L{BetaOmega2Tuple},
+       L{BetaOmega3Tuple} and L{Jacobi2Tuple}.
     '''
-    def _toDegrees(self, a, b, *c, **toDMS_kwds):
-        a, b, _ = _toDegrees(self, a, b, **toDMS_kwds)
-        return _ or self.classof(a, b, *c, name=self.name)
+    def _toDegrees(self, name, **toDMS_kwds):
+        '''(INTERNAL) Convert C{self[0:2]} to L{Degrees} or C{toDMS}.
+        '''
+        return self._toX3U(_NamedTupleTo._Degrees3, Degrees, name, *self, **toDMS_kwds)
+
+    def _toRadians(self, name):
+        '''(INTERNAL) Convert C{self[0:2]} to L{Radians}.
+        '''
+        return self._toX3U(_NamedTupleTo._Radians3, Radians, name, *self)
 
-    def _toRadians(self, a, b, *c):
-        a, b, _ = _toRadians(self, a, b)
-        return _ or self.classof(a, b, *c, name=self.name)
+    def _toX3U(self, _X3, U, name, a, b, *c, **kwds):
+        a, b, s = _X3(self, a, b, **kwds)
+        if s is None or name:
+            n = self._name__(name)
+            s = self.classof(a, b, *c, name=n).reUnit(U, U).toUnits()
+        return s
 
 
-class BetaOmega2Tuple(_NamedTupleTo):
+class BetaOmega2Tuple(_NamedTupleToX):
     '''2-Tuple C{(beta, omega)} with I{ellipsoidal} lat- and
        longitude C{beta} and C{omega} both in L{Radians} (or
        L{Degrees}).
@@ -86,27 +96,30 @@ class BetaOmega2Tuple(_NamedTupleTo):
     _Names_ = (_beta_, _omega_)
     _Units_ = (_Pass,  _Pass)
 
-    def toDegrees(self, **toDMS_kwds):
+    def toDegrees(self, name=NN, **toDMS_kwds):
         '''Convert this L{BetaOmega2Tuple} to L{Degrees} or C{toDMS}.
 
-           @return: L{BetaOmega2Tuple}C{(beta, omega)} with
-                    C{beta} and C{omega} both in L{Degrees}
-                    or as a L{toDMS} string provided some
-                    B{C{toDMS_kwds}} keyword arguments are
+           @kwarg name: Optional name (C{str}), overriding this name.
+
+           @return: L{BetaOmega2Tuple}C{(beta, omega)} with C{beta} and
+                    C{omega} both in L{Degrees} or as L{toDMS} strings
+                    provided some B{C{toDMS_kwds}} keyword arguments are
                     specified.
         '''
-        return _NamedTupleTo._toDegrees(self, *self, **toDMS_kwds)
+        return self._toDegrees(name, **toDMS_kwds)
 
-    def toRadians(self):
+    def toRadians(self, **name):
         '''Convert this L{BetaOmega2Tuple} to L{Radians}.
 
-           @return: L{BetaOmega2Tuple}C{(beta, omega)} with
-                    C{beta} and C{omega} both in L{Radians}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
+
+           @return: L{BetaOmega2Tuple}C{(beta, omega)} with C{beta} and C{omega}
+                    both in L{Radians}.
         '''
-        return _NamedTupleTo._toRadians(self, *self)
+        return self._toRadians(name)
 
 
-class BetaOmega3Tuple(_NamedTupleTo):
+class BetaOmega3Tuple(_NamedTupleToX):
     '''3-Tuple C{(beta, omega, height)} with I{ellipsoidal} lat- and
        longitude C{beta} and C{omega} both in L{Radians} (or L{Degrees})
        and the C{height}, rather the (signed) I{distance} to the triaxial's
@@ -116,54 +129,62 @@ class BetaOmega3Tuple(_NamedTupleTo):
     _Names_ = BetaOmega2Tuple._Names_ + (_height_,)
     _Units_ = BetaOmega2Tuple._Units_ + ( Meter,)
 
-    def toDegrees(self, **toDMS_kwds):
+    def toDegrees(self, name=NN, **toDMS_kwds):
         '''Convert this L{BetaOmega3Tuple} to L{Degrees} or C{toDMS}.
 
+           @kwarg name: Optional name (C{str}), overriding this name.
+
            @return: L{BetaOmega3Tuple}C{(beta, omega, height)} with
-                    C{beta} and C{omega} both in L{Degrees} or as a
-                    L{toDMS} string provided some B{C{toDMS_kwds}}
+                    C{beta} and C{omega} both in L{Degrees} or as
+                    L{toDMS} strings provided some B{C{toDMS_kwds}}
                     keyword arguments are specified.
         '''
-        return _NamedTupleTo._toDegrees(self, *self, **toDMS_kwds)
+        return self._toDegrees(name, **toDMS_kwds)
 
-    def toRadians(self):
+    def toRadians(self, **name):
         '''Convert this L{BetaOmega3Tuple} to L{Radians}.
 
-           @return: L{BetaOmega3Tuple}C{(beta, omega, height)} with
-                    C{beta} and C{omega} both in L{Radians}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
+
+           @return: L{BetaOmega3Tuple}C{(beta, omega, height)} with C{beta}
+                    and C{omega} both in L{Radians}.
         '''
-        return _NamedTupleTo._toRadians(self, *self)
+        return self._toRadians(name)
 
-    def to2Tuple(self):
+    def to2Tuple(self, **name):
         '''Reduce this L{BetaOmega3Tuple} to a L{BetaOmega2Tuple}.
+
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
         '''
-        return BetaOmega2Tuple(*self[:2])
+        return BetaOmega2Tuple(*self[:2], name=self._name__(name))
 
 
-class Jacobi2Tuple(_NamedTupleTo):
+class Jacobi2Tuple(_NamedTupleToX):
     '''2-Tuple C{(x, y)} with a Jacobi Conformal C{x} and C{y}
        projection, both in L{Radians} (or L{Degrees}).
     '''
     _Names_ = (_x_,   _y_)
     _Units_ = (_Pass, _Pass)
 
-    def toDegrees(self, **toDMS_kwds):
+    def toDegrees(self, name=NN, **toDMS_kwds):
         '''Convert this L{Jacobi2Tuple} to L{Degrees} or C{toDMS}.
 
-           @return: L{Jacobi2Tuple}C{(x, y)} with C{x} and C{y}
-                    both in L{Degrees} or as a L{toDMS} string
-                    provided some B{C{toDMS_kwds}} keyword
-                    arguments are specified.
+           @kwarg name: Optional name (C{str}), overriding this name.
+
+           @return: L{Jacobi2Tuple}C{(x, y)} with C{x} and C{y} both
+                    in L{Degrees} or as L{toDMS} strings provided some
+                    B{C{toDMS_kwds}} keyword arguments are specified.
         '''
-        return _NamedTupleTo._toDegrees(self, *self, **toDMS_kwds)
+        return self._toDegrees(name, **toDMS_kwds)
 
-    def toRadians(self):
+    def toRadians(self, **name):
         '''Convert this L{Jacobi2Tuple} to L{Radians}.
 
-           @return: L{Jacobi2Tuple}C{(x, y)} with C{x}
-                    and C{y} both in L{Radians}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
+
+           @return: L{Jacobi2Tuple}C{(x, y)} with C{x} and C{y} both in L{Radians}.
         '''
-        return _NamedTupleTo._toRadians(self, *self)
+        return self._toRadians(name)
 
 
 class Triaxial_(_NamedEnumItem):
@@ -894,8 +915,8 @@ class Triaxial(Triaxial_):
         s =  v.times_(self._1e2ac,  # == 1 - e_sub_x**2
                       self._1e2bc,  # == 1 - e_sub_y**2
                      _1_0)
-        t = self._reverseLatLon3(s, atan2d, v, self.forwardLatLon_)
-        return LatLon3Tuple(*t, **name)
+        a, b, h = self._reverseLatLon3(s, atan2d, v, self.forwardLatLon_)
+        return LatLon3Tuple(Degrees(lat=a), Degrees(lon=b), h, **name)
 
     def _reverseLatLon3(self, s, atan2_, v, forward_):
         '''(INTERNAL) Helper for C{.reverseBetOmg} and C{.reverseLatLon}.
@@ -1158,7 +1179,7 @@ def _getitems(items, *indices):
     return type(items)(map(items.__getitem__, indices))
 
 
-def _hartzell3(pov, los, Tun):  # in .ellipsoids.hartzell4, .formy.hartzell
+def _hartzell3(pov, los, Tun):  # in .Ellipsoid.hartzell4, .formy.hartzell
     '''(INTERNAL) Hartzell's "Satellite Line-of-Sight Intersection ...",
        formula from a Point-Of-View to an I{un-/ordered} Triaxial.
     '''