pygeodesy 25.11.5__py2.py3-none-any.whl → 25.12.12__py2.py3-none-any.whl

pygeodesy/{triaxials.py → triaxials/triaxial5.py}

@@ -1,19 +1,19 @@
 
 # -*- coding: utf-8 -*-
 
-u'''Triaxal ellipsoid classes I{ordered} L{Triaxial} and I{unordered} L{Triaxial_} and Jacobi
-conformal projections L{ConformalTriaxial} and L{ConformalSphere}, transcoded from
-I{Charles Karney}'s GeographicLib 2.5.2 C++ class U{JacobiConformal
-<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1JacobiConformal.html#details>}
-to pure Python and miscellaneous classes L{BetaOmega2Tuple}, L{BetaOmega3Tuple}, L{Conformal2Tuple}
-and L{TriaxialError}.
+u'''Triaxal ellipsoid classes L{Triaxial} and I{unordered} L{Triaxial_} and Jacobi conformal projections
+L{Conformal} and L{ConformalSphere}, transcoded from I{Karney}'s GeographicLib 2.5.2 C++ class U{JacobiConformal
+<https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1JacobiConformal.html#details>} to pure
+Python and miscellaneous classes L{BetaOmega2Tuple}, L{BetaOmega3Tuple} and L{Conformal2Tuple}, I{all kept
+for backward copability}.
 
-Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2008-2024).  For more information,
-see the U{GeographicLib<https://GeographicLib.SourceForge.io>} 2.5.2 documentation.
+Copyright (C) U{Charles Karney<mailto:Karney@Alum.MIT.edu>} (2008-2024) and licensed under the MIT/X11
+License.  For more information, see the U{GeographicLib 2.5.2<https://GeographicLib.SourceForge.io>}
+I{experimental} documentation.
 
 @see: U{Geodesics on a triaxial ellipsoid<https://WikiPedia.org/wiki/Geodesics_on_an_ellipsoid#
       Geodesics_on_a_triaxial_ellipsoid>} and U{Triaxial coordinate systems and their geometrical
-      interpretation<https://www.Topo.Auth.GR/wp-content/uploads/sites/111/2021/12/09_Panou.pdf>}.
+      interpretation<https://OLD.Topo.Auth.GR/wp-content/uploads/sites/111/2021/12/09_Panou.pdf>}.
 
 @var Triaxials.Amalthea: Triaxial(name='Amalthea', a=125000, b=73000, c=64000, e2ab=0.658944, e2bc=0.231375493, e2ac=0.737856, volume=2446253479595252, area=93239507787.490371704, area_p=93212299402.670425415)
 @var Triaxials.Ariel: Triaxial(name='Ariel', a=581100, b=577900, c=577700, e2ab=0.01098327, e2bc=0.000692042, e2ac=0.011667711, volume=812633172614203904, area=4211301462766.580078125, area_p=4211301574065.829589844)
@@ -26,46 +26,48 @@ see the U{GeographicLib<https://GeographicLib.SourceForge.io>} 2.5.2 documentati
 @var Triaxials.Miranda: Triaxial(name='Miranda', a=240400, b=234200, c=232900, e2ab=0.050915557, e2bc=0.011070811, e2ac=0.061422691, volume=54926187094835456, area=698880863325.757080078, area_p=698881306767.950317383)
 @var Triaxials.Moon: Triaxial(name='Moon', a=1735550, b=1735324, c=1734898, e2ab=0.000260419, e2bc=0.000490914, e2ac=0.000751206, volume=21886698675223740416, area=37838824729886.09375, area_p=37838824733332.21875)
 @var Triaxials.Tethys: Triaxial(name='Tethys', a=535600, b=528200, c=525800, e2ab=0.027441672, e2bc=0.009066821, e2ac=0.036259685, volume=623086233855821440, area=3528073490771.394042969, area_p=3528074261832.738769531)
+@var Triaxials.WGS84_3: Triaxial(name='WGS84_3', a=6378171.36, b=6378101.609999999, c=6356751.84, e2ab=0.000021871, e2bc=0.006683505, e2ac=0.00670523, volume=1083207064030173855744, area=510065541435967.4375, area_p=510065546301413.5625)
+@var Triaxials.WGS84_3r: Triaxial(name='WGS84_3r', a=6378172, b=6378102, c=6356752, e2ab=0.00002195, e2bc=0.006683577, e2ac=0.00670538, volume=1083207266220584468480, area=510065604942135.8125, area_p=510065609807745.0)
 @var Triaxials.WGS84_35: Triaxial(name='WGS84_35', a=6378172, b=6378102, c=6356752.314245179, e2ab=0.00002195, e2bc=0.006683478, e2ac=0.006705281, volume=1083207319768789942272, area=510065621722018.125, area_p=510065626587483.3125)
 '''
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # noqa: E702 ;
 
-from pygeodesy.basics import _isin, isLatLon, isscalar
-from pygeodesy.constants import EPS, EPS0, EPS02, EPS4, INT0, PI2, PI_3, PI4, \
-                               _EPS2e4, float0_, _isfinite, isnear1, _over, _SQRT2_2, \
-                               _0_0, _0_5, _1_0, _N_1_0, _64_0,  _4_0  # PYCHOK used!
-from pygeodesy.datums import Datum, _spherical_datum, _WGS84,  Ellipsoid, _EWGS84, Fmt
+from pygeodesy.angles import _SinCos2,  Property_RO
+from pygeodesy.basics import _isin, isLatLon
+from pygeodesy.constants import EPS, EPS0, EPS02, _EPS2e4, INT0, \
+                               _isfinite, isnear1, _over, _SQRT2_2, \
+                               _0_0, _0_5, _1_0, _N_1_0, _64_0
+from pygeodesy.datums import Datum, _spherical_datum, _WGS84,  _EWGS84, Fmt
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
 # from pygeodesy.elliptic import Elliptic  # _MODS
-from pygeodesy.errors import _AssertionError, _ValueError
-from pygeodesy.fmath import Fdot, fdot, fmean_, hypot, hypot_, norm2, sqrt0
-from pygeodesy.fsums import _Fsumf_, fsumf_, fsum1f_
-from pygeodesy.interns import NN, _a_, _b_, _beta_, _c_, _distant_, _DMAIN_, \
-                             _finite_, _height_, _inside_, _near_, _negative_, \
-                             _not_, _NOTEQUAL_, _null_, _opposite_, _outside_, \
-                             _SPACE_, _spherical_, _too_, _x_, _y_
-# from pygeodesy.karney import _norm2  # _MODS
-# from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .vector3d
-from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _NamedEnum, \
-                                _NamedEnumItem, _Pass
-from pygeodesy.namedTuples import LatLon3Tuple, _NamedTupleTo, Vector3Tuple, \
-                                  Vector4Tuple
-from pygeodesy.props import Property_RO, property_ROver
+from pygeodesy.errors import _AssertionError, _ValueError, _xkwds_pop2
+from pygeodesy.fmath import Fdot, fdot, hypot, hypot_,  fabs, sqrt
+from pygeodesy.fsums import fsumf_, fsum1f_
+from pygeodesy.interns import NN, _beta_, _distant_, _DMAIN_, _finite_, _height_, \
+                             _inside_, _near_, _negative_, _not_, _null_, _opposite_, \
+                             _outside_, _too_, _x_, _y_
+from pygeodesy.lazily import _ALL_LAZY, _FOR_DOCS
+from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _NamedEnum, _Pass
+from pygeodesy.namedTuples import LatLon3Tuple, _NamedTupleTo, Vector2Tuple, \
+                                  Vector3Tuple, Vector4Tuple
+# from pygeodesy.props import Property_RO  # from .triaxials.angles
 # from pygeodesy.streprs import Fmt  # from .datums
-from pygeodesy.units import Degrees, Float, Height_, Meter, Meter2, Meter3, \
-                            Radians, Radius_, Scalar_
-from pygeodesy.utily import asin1, atan2, atan2d, km2m, m2km, SinCos2, sincos2d_
-from pygeodesy.vector3d import _otherV3d, Vector3d,  _ALL_LAZY, _MODS
+from pygeodesy.triaxials.bases import Conformal5Tuple, _HeightINT0, _hypot2_1, \
+                                     _not_ordered_, _OrderedTriaxialBase, _over0, \
+                                     _otherV3d_, _over02, _sqrt0, TriaxialError, \
+                                     _Triaxial3Base, _UnOrderedTriaxialBase
+from pygeodesy.units import Degrees, Height_, Lat, Lon, Meter, Radians, Radius_, Scalar_
+from pygeodesy.utily import atan2, atan2d, km2m, m2km
+from pygeodesy.vector3d import _otherV3d, Vector3d
 
-from math import fabs, sqrt
+# from math import fabs, sqrt  # from .fmath
 
-__all__ = _ALL_LAZY.triaxials
-__version__ = '25.10.30'
+__all__ = _ALL_LAZY.triaxials_triaxial5
+__version__ = '25.11.29'
 
-_not_ordered_ = _not_('ordered')
-_omega_       = 'omega'
-_TRIPS        =  359  # Eberly 1074?
+_omega_ = 'omega'
+_TRIPS  =  359  # Eberly 1074?
 
 
 class _NamedTupleToX(_NamedTupleTo):  # in .testNamedTuples
@@ -188,9 +190,27 @@ class Conformal2Tuple(_NamedTupleToX):
         '''
         return self._toRadians(name)
 
+    def to5Tuple(self, b_conformal, **z_scale_name):
+        '''Return this L{Conformal2Tuple} as a L{Conformal5Tuple}.
 
-class Triaxial_(_NamedEnumItem):
-    '''I{Unordered} triaxial ellipsoid and base class.
+           @arg b_conformal: Middle semi-axis (C{meter}, conventionally)
+                             or the original L{Conformal} of this 2-tuple.
+           @kwarg z_scale_name: Optional C{B{z}=0} meter, C{B{scale}=NAN}
+                                and C{B{name}=NN} (C{str}).
+
+           @return: A L{Conformal5Tuple}.
+        '''
+        if isinstance(b_conformal, Conformal):
+            b = b_conformal.b
+        else:
+            b = Radius_(b=b_conformal)
+        x, y =  self.toRadians()
+        x, y = _over(x, b), _over(y, b)
+        return Conformal5Tuple(x, y, **z_scale_name)
+
+
+class Triaxial_(_UnOrderedTriaxialBase):
+    '''I{Unordered} triaxial ellipsoid.
 
        Triaxial ellipsoids with right-handed semi-axes C{a}, C{b} and C{c}, oriented
        such that the large principal ellipse C{ab} is the equator I{Z}=0, I{beta}=0,
@@ -205,568 +225,35 @@ class Triaxial_(_NamedEnumItem):
               longitude C{beta} and C{omega} are in L{Radians} by default (or in
               L{Degrees} if converted).
     '''
-    _ijk = _kji = None
-    _unordered  = True
-
-    def __init__(self, a_triaxial, b=None, c=None, **name):
-        '''New I{unordered} L{Triaxial_}.
-
-           @arg a_triaxial: Large, C{X} semi-axis (C{scalar}, conventionally in
-                            C{meter}) or an other L{Triaxial} or L{Triaxial_} instance.
-           @kwarg b: Middle, C{Y} semi-axis (C{meter}, same units as B{C{a}}), required
-                     if C{B{a_triaxial} is scalar}, ignored otherwise.
-           @kwarg c: Small, C{Z} semi-axis (C{meter}, like B{C{b}}).
-           @kwarg name: Optional C{B{name}=NN} (C{str}).
-
-           @raise TriaxialError: Invalid semi-axis or -axes.
-        '''
-        try:
-            try:
-                a = a_triaxial
-                t = a._abc3
-            except AttributeError:
-                t = Radius_(a=a), Radius_(b=b), Radius_(c=c)
-        except (TypeError, ValueError) as x:
-            raise TriaxialError(a=a, b=b, c=c, cause=x)
-        if name:
-            self.name = name
-
-        a, b, c = self._abc3 = t
-        if self._unordered:  # == not isinstance(self, Triaxial)
-            s, _, t = sorted(t)
-            if not (_isfinite(t) and s > 0):
-                raise TriaxialError(a=a, b=b, c=c)  # txt=_invalid_
-        elif not (_isfinite(a) and a >= b >= c > 0):  # see Triaxial2
-            raise TriaxialError(a=a, b=b, c=c, txt=_not_ordered_)
-        elif not (a > c and self._a2c2 > 0 and self.e2ac > 0):
-            raise TriaxialError(a=a, c=c, e2ac=self.e2ac, txt=_spherical_)
-
-    def __str__(self):
-        return self.toStr()
-
-    @Property_RO
-    def a(self):
-        '''Get the C{largest, x} semi-axis (C{meter}, conventionally).
-        '''
-        a, _, _ = self._abc3
-        return a
-
-    @Property_RO
-    def a2(self):
-        '''Get C{a**2}.
-        '''
-        return self.a**2
-
-    @Property_RO
-    def _a2b2(self):
-        '''(INTERNAL) Get C{a**2 - b**2} == E_sub_e**2.
-        '''
-        a, b, _ = self._abc3
-        return ((a - b) * (a + b)) if a != b else _0_0
-
-    @Property_RO
-    def _a2_b2(self):
-        '''(INTERNAL) Get C{(a / b)**2}.
-        '''
-        a, b, _ = self._abc3
-        return (a / b)**2 if a != b else _1_0
-
-    @Property_RO
-    def _a2b2c23(self):
-        '''(INTERNAL) Get 3-tuple C{(a**2, b**2, c**2)}.
-        '''
-        a, b, c = self._abc3
-        return self.a2, self.b2, self.c2
-
-    @Property_RO
-    def _a2c2(self):
-        '''(INTERNAL) Get C{a**2 - c**2} == E_sub_x**2.
-        '''
-        a, _, c = self._abc3
-        return ((a - c) * (a + c)) if a != c else _0_0
-
-    @Property_RO
-    def area(self):
-        '''Get the surface area (C{meter} I{squared}).
-        '''
-        c, b, a = sorted(self._abc3)
-        return Triaxial(a, b, c).area if a > c else \
-               Meter2(area=self.a2 * PI4)  # a == c == b
-
-    def area_p(self, p=1.6075):
-        '''I{Approximate} the surface area (C{meter} I{squared}).
-
-           @kwarg p: Exponent (C{scalar} > 0), 1.6 for near-spherical or 1.5849625007
-                     for "near-flat" triaxials.
-
-           @see: U{Surface area<https://WikiPedia.org/wiki/Ellipsoid#Approximate_formula>}.
-        '''
-        a, b, c = self._abc3
-        if a == b == c:
-            a *= a
-        else:
-            _p = pow
-            a = _p(fmean_(_p(a * b, p), _p(a * c, p), _p(b * c, p)), _1_0 / p)
-        return Meter2(area_p=a * PI4)
-
-    @Property_RO
-    def b(self):
-        '''Get the C{middle, y} semi-axis (C{meter}, same units as B{C{a}}).
-        '''
-        _, b, _ = self._abc3
-        return b
-
-    @Property_RO
-    def b2(self):
-        '''Get C{b**2}.
-        '''
-        return self.b**2
-
-    @Property_RO
-    def _b2_a2(self):
-        '''(INTERNAL) Get C{(b / a)**2}.
-        '''
-        a, b, _ = self._abc3
-        return (b / a)**2 if a != b else _1_0
-
-    @Property_RO
-    def _b2c2(self):
-        '''(INTERNAL) Get C{b**2 - c**2} == E_sub_y**2.
-        '''
-        _, b, c = self._abc3
-        return ((b - c) * (b + c)) if b != c else _0_0
-
-    @Property_RO
-    def c(self):
-        '''Get the C{smallest, z} semi-axis (C{meter}, same units as B{C{a}}).
-        '''
-        _, _, c = self._abc3
-        return c
-
-    @Property_RO
-    def c2(self):
-        '''Get C{c**2}.
-        '''
-        return self.c**2
-
-    @Property_RO
-    def _c2_a2(self):
-        '''(INTERNAL) Get C{(c / a)**2}.
-        '''
-        a, _, c = self._abc3
-        return (c / a)**2 if a != c else _1_0
-
-    @Property_RO
-    def _c2_b2(self):
-        '''(INTERNAL) Get C{(c / b)**2}.
-        '''
-        _, b, c = self._abc3
-        return (c / b)**2 if b != c else _1_0
-
-    @Property_RO
-    def e2ab(self):
-        '''Get the C{ab} ellipse' I{(1st) eccentricity squared} (C{scalar}), M{1 - (b/a)**2}.
-        '''
-        return Float(e2ab=(_1_0 - self._b2_a2) or _0_0)
-
-#   _1e2ab = _b2_a2  # C{1 - e2ab} == C{(b / a)**2}
-
-    @Property_RO
-    def e2ac(self):
-        '''Get the C{ac} ellipse' I{(1st) eccentricity squared} (C{scalar}), M{1 - (c/a)**2}.
-        '''
-        return Float(e2ac=(_1_0 - self._c2_a2) or _0_0)
-
-#   _1e2ac = _c2_a2  # C{1 - e2ac} == C{(c / a)**2}
-
-    @Property_RO
-    def e2bc(self):
-        '''Get the C{bc} ellipse' I{(1st) eccentricity squared} (C{scalar}), M{1 - (c/b)**2}.
-        '''
-        return Float(e2bc=(_1_0 - self._c2_b2) or _0_0)
-
-#   _1e2bc = _c2_b2  # C{1 - e2bc} == C{(c / b)**2}
-
-    @property_ROver
-    def _Elliptic(self):
-        '''(INTERNAL) Get class L{Elliptic}, I{once}.
-        '''
-        return _MODS.elliptic.Elliptic  # overwrite property_ROver
-
-    def hartzell4(self, pov, los=False, **name):
-        '''Compute the intersection of this triaxial's surface with a Line-Of-Sight
-           from a Point-Of-View in space.
-
-           @see: Function L{hartzell4<triaxials.hartzell4>} for further details.
-        '''
-        return hartzell4(pov, los=los, tri_biax=self, **name)
-
-    def height4(self, x_xyz, y=None, z=None, normal=True, eps=EPS, **name):
-        '''Compute the projection on and the height above or below this triaxial's surface.
-
-           @arg x_xyz: X component (C{scalar}) or a cartesian (C{Cartesian}, L{Ecef9Tuple},
-                       L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
-           @kwarg y: Y component (C{scalar}), required if B{C{x_xyz}} if C{scalar}, ignored
-                     otherwise.
-           @kwarg z: Z component (C{scalar}), like B{C{y}}.
-           @kwarg normal: If C{True}, the projection is the I{perpendicular, plumb} to the
-                          triaxial's surface, otherwise the C{radial} line to the center of
-                          this triaxial (C{bool}).
-           @kwarg eps: Tolerance for root finding and validation (C{scalar}), use a negative
-                       value to skip validation.
-           @kwarg name: Optional C{B{name}="height4"} (C{str}).
-
-           @return: L{Vector4Tuple}C{(x, y, z, h)} with the cartesian coordinates C{x}, C{y}
-                    and C{z} of the projection on or the intersection with and with the height
-                    C{h} above or below the triaxial's surface in C{meter}, conventionally.
-
-           @raise TriaxialError: Non-cartesian B{C{xyz}}, invalid B{C{eps}}, no convergence in
-                  root finding or validation failed.
-
-           @see: Methods L{Triaxial.normal3d} and L{Ellipsoid.height4}, I{Eberly}'s U{Distance from a Point to ...
-                 <https://www.GeometricTools.com/Documentation/DistancePointEllipseEllipsoid.pdf>} and I{Bektas}'
-                 U{Shortest Distance from a Point to Triaxial Ellipsoid<https://www.ResearchGate.net/publication/
-                 272149005_SHORTEST_DISTANCE_FROM_A_POINT_TO_TRIAXIAL_ELLIPSOID>}.
-        '''
-        v, r = _otherV3d_(x_xyz, y, z), self.isSpherical
-
-        i, h = None, v.length
-        if h < EPS0:  # EPS
-            x = y = z = _0_0
-            h -= min(self._abc3)  # nearest
-        elif r:  # .isSpherical
-            x, y, z = v.times(r / h).xyz3
-            h -= r
-        else:
-            x, y, z = v.xyz3
-            try:
-                if normal:  # plumb to surface
-                    x, y, z, h, i = _plumbTo5(x, y, z, self, eps=eps)
-                else:  # radial to center
-                    x, y, z = self._radialTo3(z, hypot(x, y), y, x)
-                    h = v.minus_(x, y, z).length
-            except Exception as e:
-                raise TriaxialError(x=x, y=y, z=z, cause=e)
-            if h > 0 and self.sideOf(v, eps=EPS0) < 0:
-                h = -h  # inside
-        n = _name__(name, name__=self.height4)  # typename
-        return Vector4Tuple(x, y, z, h, iteration=i, name=n)
-
-    @Property_RO
-    def isOrdered(self):
-        '''Is this triaxial I{ordered} and I{not spherical} (C{bool})?
-        '''
-        a, b, c = self._abc3
-        return bool(a >= b > c)  # b > c!
-
-    @Property_RO
-    def isSpherical(self):
-        '''Is this triaxial I{spherical} (C{Radius} or INT0)?
-        '''
-        a, b, c = self._abc3
-        return a if a == b == c else INT0
-
-    def _norm2(self, s, c, *a):
-        '''(INTERNAL) Normalize C{s} and C{c} iff not already.
-        '''
-        if fabs(_hypot2_1(s, c)) > EPS02:
-            s, c = norm2(s, c)
-        if a:
-            s, c = norm2(s * self.b, c * a[0])
-        return float0_(s, c)
-
-    def normal3d(self, x_xyz, y=None, z=None, length=_1_0):
-        '''Get a 3-D vector I{on and perpendicular to} this triaxial's surface.
-
-           @arg x_xyz: X component (C{scalar}) or a cartesian (C{Cartesian},
-                       L{Ecef9Tuple}, L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
-           @kwarg y: Y component (C{scalar}), required if B{C{x_xyz}} if C{scalar}, ignored
-                     otherwise.
-           @kwarg z: Z component (C{scalar}), like B{C{y}}.
-           @kwarg length: Optional, signed length in out-/inward direction (C{scalar}).
-
-           @return: A C{Vector3d(x_, y_, z_)} normalized to B{C{length}}, pointing out-
-                    or inward for postive respectively negative B{C{length}}.
-
-           @raise TriaxialError: Zero length cartesian or vector.
-
-           @note: Cartesian C{(B{x}, B{y}, B{z})} I{must be on} this triaxial's surface,
-                  use method L{Triaxial.sideOf} to validate.
-
-           @see: Methods L{Triaxial.height4} and L{Triaxial.sideOf}.
-        '''
-        # n = 2 * (x / a2, y / b2, z / c2)
-        #  == 2 * (x, y * a2 / b2, z * a2 / c2) / a2  # iff ordered
-        #  == 2 * (x, y / _b2_a2, z / _c2_a2) / a2
-        #  == unit(x, y / _b2_a2, z / _c2_a2).times(length)
-        x, y, z = _otherV3d_(x_xyz, y, z).xyz3
-        n = Vector3d(x, y / self._b2_a2,
-                        z / self._c2_a2, name__=self.normal3d)
-        u = n.length
-        if u < EPS0:
-            raise TriaxialError(x=x_xyz, y=y, z=z, txt=_null_)
-        return n.times(length / u)
-
-    def normal4(self, x_xyz, y=None, z=None, height=0, normal=True):
-        '''Compute a cartesian above or below this triaxial's surface.
-
-           @arg x_xyz: X component (C{scalar}) or a cartesian (C{Cartesian}, L{Ecef9Tuple},
-                       L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
-           @kwarg y: Y component (C{scalar}), required if B{C{x_xyz}} if C{scalar}, ignored
-                     otherwise.
-           @kwarg z: Z component (C{scalar}), like B{C{y}}.
-           @kwarg height: The signed height (C{scalar}, same units as the triaxial axes).
-           @kwarg normal: If C{True}, the B{C{height}} is I{perpendicular, plumb} to the
-                          triaxial's surface, otherwise C{radially} to the center of this
-                          triaxial (C{bool}).
-           @kwarg name: Optional C{B{name}="normal4"} (C{str}).
-
-           @return: L{Vector4Tuple}C{(x, y, z, h)} with the cartesian coordinates C{x},
-                    C{y} and C{z} and C{h} the I{signed, normal distance} to the triaxial's
-                    surface in C{meter}, conventionally.  Positive C{h} indicates, the
-                    cartesian is outside the triaxial, negative C{h} means inside.
-
-           @raise TriaxialError: Zero length cartesian or vector.
-
-           @note: Cartesian C{(B{x}, B{y}, B{z})} I{must be on} this triaxial's surface,
-                  use method L{Triaxial.sideOf} to validate.
-
-           @see: Methods L{Triaxial.normal3d} and L{Triaxial.height4}.
-        '''
-        v, h = _otherV3d(x_xyz, y, z), Height_(height, low=None)
-        if h:
-            if v.length < EPS0:
-                raise TriaxialError(x=x_xyz, y=y, z=z, txt=_null_)
-            if normal:
-                n  = self.normal3d(v, length=h)
-                h  = n.length
-                n += v
-            else:
-                h = h / v.length
-                n = v.times(h + _1_0)
-        else:
-            n = v
-        return Vector4Tuple(n.x, n.y, n.z, h, name__=self.normal4)
+    if _FOR_DOCS:
+        __init__ = _UnOrderedTriaxialBase.__init__
 
-    def _order3(self, *abc, **reverse):  # reverse=False
-        '''(INTERNAL) Un-/Order C{a}, C{b} and C{c}.
 
-           @return: 3-Tuple C{(a, b, c)} ordered by or un-ordered
-                    (reverse-ordered) C{ijk} if C{B{reverse}=True}.
-        '''
-        ijk = self._order_ijk(**reverse)
-        return _getitems(abc, *ijk) if ijk else abc
-
-    def _order3d(self, v, **reverse):  # reverse=False
-        '''(INTERNAL) Un-/Order a C{Vector3d}.
-
-           @return: Vector3d(x, y, z) un-/ordered.
-        '''
-        ijk = self._order_ijk(**reverse)
-        return v.classof(*_getitems(v.xyz3, *ijk)) if ijk else v
-
-    @Property_RO
-    def _ordered4(self):
-        '''(INTERNAL) Helper for C{_hartzell3} and C{_plumbTo5}.
-        '''
-        def _order2(reverse, a, b, c):
-            '''(INTERNAL) Un-Order C{a}, C{b} and C{c}.
-
-               @return: 2-Tuple C{((a, b, c), ijk)} with C{a} >= C{b} >= C{c}
-                        and C{ijk} a 3-tuple with the initial indices.
-            '''
-            i, j, k = range(3)
-            if a < b:
-                a, b, i, j = b, a, j, i
-            if a < c:
-                a, c, i, k = c, a, k, i
-            if b < c:
-                b, c, j, k = c, b, k, j
-            # reverse (k, j, i) since (a, b, c) is reversed-sorted
-            ijk = (k, j, i) if reverse else (None if i < j < k else (i, j, k))
-            return (a, b, c), ijk
-
-        abc, T = self._abc3, self
-        if not self.isOrdered:
-            abc, ijk = _order2(False, *abc)
-            if ijk:
-                _, kji = _order2(True, *ijk)
-                T = Triaxial_(*abc)
-                T._ijk, T._kji = ijk, kji
-        return abc + (T,)
-
-    def _order_ijk(self, reverse=False):
-        '''(INTERNAL) Get the un-/order indices.
-        '''
-        return self._kji if reverse else self._ijk
-
-    def _radialTo3(self, sbeta, cbeta, somega, comega):
-        '''(INTERNAL) I{Unordered} helper for C{.height4}.
-        '''
-        def _rphi(a, b, sphi, cphi):
-            # <https://WikiPedia.org/wiki/Ellipse#Polar_form_relative_to_focus>
-            # polar form: radius(phi) = a * b / hypot(a * sphi, b * cphi)
-            return (b / hypot(sphi, b / a * cphi)) if a > b else (
-                   (a / hypot(cphi, a / b * sphi)) if a < b else a)
-
-        sa, ca = self._norm2(sbeta,  cbeta)
-        sb, cb = self._norm2(somega, comega)
-
-        a, b, c = self._abc3
-        if a != b:
-            a = _rphi(a, b, sb, cb)
-        if a != c:
-            c = _rphi(a, c, sa, ca)
-        t = c * ca
-        return (t * cb), (t * sb), (c * sa)
-
-    def sideOf(self, x_xyz, y=None, z=None, eps=EPS4):
-        '''Is a cartesian on, above or below the surface of this triaxial?
-
-           @arg x_xyz: X component (C{scalar}) or a cartesian (C{Cartesian},
-                       L{Ecef9Tuple}, L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
-           @kwarg y: Y component (C{scalar}), required if B{C{x_xyz}} is C{scalar},
-                     ignored otherwise.
-           @kwarg z: Z component (C{scalar}), like B{C{y}}.
-           @kwarg eps: On-surface tolerance (C{scalar}, distance I{squared}).
-
-           @return: C{INT0} if C{(B{x}, B{y}, B{z})} is near this triaxial's surface
-                    within tolerance B{C{eps}}, otherwise the signed, radial distance
-                    I{squared} (C{float}), negative for in- or positive for outside
-                    this triaxial.
-
-           @see: Methods L{Triaxial.height4} and L{Triaxial.normal3d}.
-        '''
-        v = _otherV3d_(x_xyz, y, z)
-        s =  fsumf_(_N_1_0, *map(_over02, v.xyz3, self._abc3))
-        return INT0 if fabs(s) < eps else s
-
-    def toEllipsoid(self, **name):
-        '''Convert this triaxial to a I{biaxial} L{Ellipsoid}, provided 2 axes match.
-
-           @kwarg name: Optional C{B{name}=NN} (C{str}).
-
-           @return: An L{Ellipsoid} with north along this C{Z} axis if C{a == b},
-                    this C{Y} axis if C{a == c} or this C{X} axis if C{b == c}.
-
-           @raise TriaxialError: This C{a != b}, C{b != c} and C{c != a}.
-
-           @see: Method L{Ellipsoid.toTriaxial}.
-        '''
-        a, b, c = self._abc3
-        if a == b:
-            b = c  # N = c-Z
-        elif b == c:  # N = a-X
-            a, b = b, a
-        elif a != c:  # N = b-Y
-            t = _SPACE_(_a_, _NOTEQUAL_, _b_, _NOTEQUAL_, _c_)
-            raise TriaxialError(a=a, b=b, c=c, txt=t)
-        return Ellipsoid(a, b=b, name=self._name__(name))
-
-    toBiaxial = toEllipsoid
-
-    def toStr(self, prec=9, **name):  # PYCHOK signature
-        '''Return this C{Triaxial} as a string.
-
-           @kwarg prec: Precision, number of decimal digits (0..9).
-           @kwarg name: Optional name (C{str}), to override or C{None}
-                        to exclude this triaxial's name.
-
-           @return: This C{Triaxial}'s attributes (C{str}).
-        '''
-        T  = Triaxial_
-        t  = T.a,  # props
-        J  = ConformalSphere
-        t += (J.ab, J.bc) if isinstance(self, J) else (T.b, T.c)
-        t += T.e2ab, T.e2bc, T.e2ac
-        J  = ConformalTriaxial
-        if isinstance(self, J):
-            t += J.xyQ2,
-        t += T.volume, T.area
-        return self._instr(area_p=self.area_p(), prec=prec, props=t, **name)
-
-    @Property_RO
-    def unOrdered(self):
-        '''Is this triaxial I{un-ordered} and I{not spherical} (C{bool})?
-        '''
-        return not (self.isOrdered or bool(self.isSpherical))
-
-    @Property_RO
-    def volume(self):
-        '''Get the volume (C{meter**3}), M{4 / 3 * PI * a * b * c}.
-        '''
-        a, b, c = self._abc3
-        return Meter3(volume=a * b * c * PI_3 * _4_0)
-
-
-class Triaxial(Triaxial_):
+class Triaxial(_OrderedTriaxialBase):
     '''I{Ordered} triaxial ellipsoid.
 
        @see: L{Triaxial_} for more information.
     '''
-    _unordered = False
-
-    def __init__(self, a_triaxial, b=None, c=None, **name):
-        '''New I{ordered} L{Triaxial}.
-
-           @arg a_triaxial: Largest semi-axis (C{scalar}, conventionally in C{meter})
-                            or an other L{Triaxial} or L{Triaxial_} instance.
-           @kwarg b: Middle semi-axis (C{meter}, same units as B{C{a}}), required
-                     if C{B{a_triaxial} is scalar}, ignored otherwise.
-           @kwarg c: Smallest semi-axis (C{meter}, like B{C{b}}).
-           @kwarg name: Optional C{B{name}=NN} (C{str}).
-
-           @note: The semi-axes must be ordered as C{B{a} >= B{b} >= B{c} > 0} and
-                  must be ellipsoidal, C{B{a} > B{c}}.
-
-           @raise TriaxialError: Semi-axes unordered, spherical or invalid.
-        '''
-        Triaxial_.__init__(self, a_triaxial, b=b, c=c, **name)
-
-    @Property_RO
-    def _a2b2_a2c2(self):
-        '''@see: Methods C{.forwardBetaOmega} and property C{._k2E_kp2E}.
-        '''
-        s = self._a2c2
-        if s:
-            s = self._a2b2 / s
-        return s or _0_0
-
-    @Property_RO
-    def area(self):
-        '''Get the surface area (C{meter} I{squared}).
+    if _FOR_DOCS:
+        __init__ = _OrderedTriaxialBase.__init__
 
-           @see: U{Surface area<https://WikiPedia.org/wiki/Ellipsoid#Surface_area>}.
-        '''
-        a, b, c = self._abc3
-        if a != b:
-            kp2, k2 = self._k2E_kp2E  # swapped!
-            aE = self._Elliptic(k2, _0_0, kp2, _1_0)
-            c2 = self._c2_a2      # cos(phi)**2 = (c/a)**2
-            s  = sqrt(self.e2ac)  # sin(phi)**2 =  1 - c2
-            r  = asin1(s)  # phi = atan2(sqrt(c2), s)
-            b *= fsum1f_(aE.fE(r) * s, (c / a) * (c / b),
-                         aE.fF(r) * c2 / s)
-            a  = Meter2(area=a * b * PI2)
-        else:  # a == b > c
-            a  = Ellipsoid(a, b=c).areax
-        return a
-
-    def forwardBetaOmega(self, beta, omega, height=0, **name):
+    def forwardBetaOmega(self, beta, omega, height=0, **unit_name):
         '''Convert I{ellipsoidal} lat- C{beta}, longitude C{omega} and C{height}
            to cartesian.
 
-           @arg beta: Ellipsoidal latitude (C{radians} or L{Degrees}).
-           @arg omega: Ellipsoidal longitude (C{radians} or L{Degrees}).
-           @arg height: Height above or below the ellipsoid's surface (C{meter},
-                        same units as this triaxial's C{a}, semi-axes).
-           @kwarg name: Optional C{B{name}=NN} (C{str}).
+           @arg beta: Ellipsoidal latitude (C{Ang} or B{C{unit}}).
+           @arg omega: Ellipsoidal longitude (C{Ang} or B{C{unit}}).
+           @kwarg height: Height above or below the triaxial's surface (C{meter},
+                          same units as this triaxial's semi-axes.
+           @kwarg unit_name: Optional C{B{name}=NN} (C{str}) and scalar
+                             C{B{unit}=}L{Radians} (or L{Degrees}).
 
            @return: A L{Vector3Tuple}C{(x, y, z)}.
 
-           @see: Method L{Triaxial.reverseBetaOmega} and U{expressions (23-25)<https://
-                 www.Topo.Auth.GR/wp-content/uploads/sites/111/2021/12/09_Panou.pdf>}.
+           @see: Method L{Triaxial.reverseBetaOmega} and U{equations (23-25)<https://
+                 OLD.Topo.Auth.GR/wp-content/uploads/sites/111/2021/12/09_Panou.pdf>}.
         '''
+        unit, name = _xkwds_pop2(unit_name, unit=Radians)
         if height:
             z = self._Height(height) + self.c
             if z > 0:
@@ -778,8 +265,8 @@ class Triaxial(Triaxial_):
         else:
             x, y, z = self._abc3
         if z:  # and x and y:
-            sa, ca = SinCos2(beta)
-            sb, cb = SinCos2(omega)
+            sa, ca = _SinCos2(beta,  unit)
+            sb, cb = _SinCos2(omega, unit)
 
             r  = self._a2b2_a2c2
             x *= cb * (_sqrt0(ca**2 + sa**2 * r) if r else fabs(ca))
@@ -788,8 +275,8 @@ class Triaxial(Triaxial_):
         return Vector3Tuple(x, y, z, **name)
 
     def forwardBetaOmega_(self, sbeta, cbeta, somega, comega, **name):
-        '''Convert I{ellipsoidal} lat- C{beta} and longitude C{omega}
-           to cartesian coordinates I{on the triaxial's surface}.
+        '''Convert I{ellipsoidal} lat- and longitude C{beta} and C{omega}
+           to cartesian coordinates I{on this triaxial's surface}.
 
            @arg sbeta: Ellipsoidal latitude C{sin(beta)} (C{scalar}).
            @arg cbeta: Ellipsoidal latitude C{cos(beta)} (C{scalar}).
@@ -803,44 +290,50 @@ class Triaxial(Triaxial_):
 
            @see: Method L{Triaxial.reverseBetaOmega}, U{Triaxial ellipsoid coordinate
                  system<https://WikiPedia.org/wiki/Geodesics_on_an_ellipsoid#
-                 Triaxial_ellipsoid_coordinate_system>} and U{expressions (23-25)<https://
-                 www.Topo.Auth.GR/wp-content/uploads/sites/111/2021/12/09_Panou.pdf>}.
+                 Triaxial_ellipsoid_coordinate_system>} and U{equations (23-25)<https://
+                 OLD.Topo.Auth.GR/wp-content/uploads/sites/111/2021/12/09_Panou.pdf>}.
         '''
         t = self._radialTo3(sbeta, cbeta, somega, comega)
         return Vector3Tuple(*t, **name)
 
-    def forwardCartesian(self, x_xyz, y=None, z=None, **normal_eps_name):
-        '''Project a cartesian on this triaxial.
+    def forwardCartesian(self, x_xyz, y=None, z=None, normal=True, **eps_name):
+        '''Project any cartesian to a cartesian I{on this triaxial's surface}.
 
            @arg x_xyz: X component (C{scalar}) or a cartesian (C{Cartesian},
                        L{Ecef9Tuple}, L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
            @kwarg y: Y component (C{scalar}), required if B{C{x_xyz}} is C{scalar},
                      ignored otherwise.
            @kwarg z: Z component (C{scalar}), like B{C{y}}.
-           @kwarg normal_eps_name: Optional keyword arguments C{B{normal}=True},
-                         C{B{eps}=EPS} and overriding C{B{name}="height4"} (C{str}),
-                         see method L{Triaxial.height4}.
+           @kwarg normal: If C{True}, the projection is C{perpendicular} to the surface,
+                          otherwise C{radial} to the center of this triaxial (C{bool}).
+           @kwarg eps_name: Root finder tolerance C{B{eps}=EPS} and optional
+                            C{B{name}="height4"} (C{str}).
 
-           @see: Method L{Triaxial.height4} for further information and method
-                 L{Triaxial.reverseCartesian} to reverse the projection.
+           @return: A L{Vector4Tuple}C{(x, y, z, h)}.
+
+           @see: Method L{Triaxial.reverseCartesian} to reverse the projection and
+                 function L{height4<triaxials.triaxial5.height4>} for more details.
         '''
-        return self.height4(x_xyz, y, z, **normal_eps_name)
+        return self.height4(x_xyz, y, z, normal=normal, **eps_name)
 
-    def forwardLatLon(self, lat, lon, height=0, **name):
+    def forwardLatLon(self, lat, lon, height=0, **unit_name):
         '''Convert I{geodetic} lat-, longitude and height to cartesian.
 
-           @arg lat: Geodetic latitude (C{degrees}).
-           @arg lon: Geodetic longitude (C{degrees}).
+           @arg lat: Geodetic latitude (C{Ang} or B{C{unit}}).
+           @arg lon: Geodetic longitude (C{Ang} or B{C{unit}}).
            @arg height: Height above the ellipsoid (C{meter}, same units
                         as this triaxial's semi-axes).
-           @kwarg name: Optional C{B{name}=NN} (C{str}).
+           @kwarg unit_name: Optional scalar C{B{unit}=}L{Degrees} and
+                       C{B{name}=NN} (C{str}).
 
            @return: A L{Vector3Tuple}C{(x, y, z)}.
 
-           @see: Method L{Triaxial.reverseLatLon} and U{expressions (9-11)<https://
-                 www.Topo.Auth.GR/wp-content/uploads/sites/111/2021/12/09_Panou.pdf>}.
+           @see: Method L{Triaxial.reverseLatLon} and U{equations (9-11)<https://
+                 OLD.Topo.Auth.GR/wp-content/uploads/sites/111/2021/12/09_Panou.pdf>}.
         '''
-        return self._forwardLatLon3(height, name, *sincos2d_(lat, lon))
+        unit, name = _xkwds_pop2(unit_name, unit=Degrees)
+        return self._forwardLatLon3(height, name, *(_SinCos2(lat, unit) +
+                                                    _SinCos2(lon, unit)))
 
     def forwardLatLon_(self, slat, clat, slon, clon, height=0, **name):
         '''Convert I{geodetic} lat-, longitude and height to cartesian.
@@ -855,8 +348,8 @@ class Triaxial(Triaxial_):
 
            @return: A L{Vector3Tuple}C{(x, y, z)}.
 
-           @see: Method L{Triaxial.reverseLatLon} and U{expressions (9-11)<https://
-                 www.Topo.Auth.GR/wp-content/uploads/sites/111/2021/12/09_Panou.pdf>}.
+           @see: Method L{Triaxial.reverseLatLon} and U{equations (9-11)<https://
+                 OLD.Topo.Auth.GR/wp-content/uploads/sites/111/2021/12/09_Panou.pdf>}.
         '''
         sa, ca = self._norm2(slat, clat)
         sb, cb = self._norm2(slon, clon)
@@ -865,14 +358,16 @@ class Triaxial(Triaxial_):
     def _forwardLatLon3(self, height, name, sa, ca, sb, cb):  # name always **name
         '''(INTERNAL) Helper for C{.forwardLatLon} and C{.forwardLatLon_}.
         '''
-        ca_x_sb = ca * sb
         h = self._Height(height)
+        x = ca * cb
+        y = ca * sb
+        z = sa
         # 1 - (1 - (c/a)**2) * sa**2 - (1 - (b/a)**2) * ca**2 * sb**2
-        t =  fsumf_(_1_0, -self.e2ac * sa**2, -self.e2ab * ca_x_sb**2)
-        n = _over(self.a, _sqrt0(t))  # prime vertical
-        x = (h + n)               * ca * cb
-        y = (h + n * self._b2_a2) * ca_x_sb
-        z = (h + n * self._c2_a2) * sa
+        t = fsumf_(_1_0, -self.e2ac * z**2, -self.e2ab * y**2)
+        n = self.a / _sqrt0(t)  # prime vertical
+        x *= h + n
+        y *= h + n * self._b2_a2
+        z *= h + n * self._c2_a2
         return Vector3Tuple(x, y, z, **name)
 
     def _Height(self, height):
@@ -880,41 +375,6 @@ class Triaxial(Triaxial_):
         '''
         return Height_(height=height, low=-self.c, Error=TriaxialError)
 
-    @Property_RO
-    def _k2E_kp2E(self):
-        '''(INTERNAL) Get elliptic C{k2} and C{kp2} for C{._xE}, C{._yE} and C{.area}.
-        '''
-        # k2  = a2b2 / a2c2 * c2_b2
-        # kp2 = b2c2 / a2c2 * a2_b2
-        # b2  = b**2
-        # xE  = Elliptic(k2,  -a2b2 / b2, kp2, a2_b2)
-        # yE  = Elliptic(kp2, +b2c2 / b2, k2,  c2_b2)
-        # aE  = Elliptic(kp2,  0,         k2,  1)
-        k2  =  self._c2_b2 * self._a2b2_a2c2
-        kp2 = (self._a2_b2 * self._b2c2 / self._a2c2) if k2 else _1_0
-        return (k2, kp2)
-
-    def _radialTo3(self, sbeta, cbeta, somega, comega):
-        '''(INTERNAL) Convert I{ellipsoidal} lat- and longitude C{beta} and
-           C{omega} to cartesian coordinates I{on the triaxial's surface},
-           also I{ordered} helper for C{.height4}.
-        '''
-        sa, ca  =  self._norm2(sbeta,  cbeta)
-        sb, cb  =  self._norm2(somega, comega)
-
-        b2_a2   =  self._b2_a2  # ==  (b/a)**2
-        c2_a2   = -self._c2_a2  # == -(c/a)**2
-        a2c2_a2 =  self.  e2ac  # (a**2 - c**2) / a**2 == 1 - (c/a)**2
-
-        x2 = _Fsumf_(_1_0, -b2_a2 * sa**2, c2_a2 * ca**2).fover(a2c2_a2)
-        z2 = _Fsumf_(c2_a2,         sb**2, b2_a2 * cb**2).fover(a2c2_a2)
-
-        x, y, z =  self._abc3
-        x *= cb * _sqrt0(x2)
-        y *= ca *  sb
-        z *= sa * _sqrt0(z2)
-        return x, y, z
-
     def reverseBetaOmega(self, x_xyz, y=None, z=None, **name):
         '''Convert cartesian to I{ellipsoidal} lat- and longitude, C{beta}, C{omega}
            and height.
@@ -931,41 +391,40 @@ class Triaxial(Triaxial_):
                     units as this triaxial's semi-axes.
 
            @see: Methods L{Triaxial.forwardBetaOmega} and L{Triaxial.forwardBetaOmega_}
-                 and U{expressions (21-22)<https://www.Topo.Auth.GR/wp-content/uploads/
+                 and U{equations (21-22)<https://OLD.Topo.Auth.GR/wp-content/uploads/
                  sites/111/2021/12/09_Panou.pdf>}.
         '''
         v = _otherV3d_(x_xyz, y, z)
         a, b, h = _reverseLatLon3(v, atan2, v, self.forwardBetaOmega_)
         return BetaOmega3Tuple(Radians(beta=a), Radians(omega=b), h, **name)
 
-    def reverseCartesian(self, x_xyz, y=None, z=None, h=0, normal=True, eps=_EPS2e4, **name):
-        '''"Unproject" a cartesian I{on} this triaxial's surface to a cartesion I{off}
-           this triaxial's surface.
+    def reverseCartesian(self, x_xyz, y=None, z=None, height=0, normal=True, eps=_EPS2e4, **name):
+        '''"Unproject" a cartesian I{off} this triaxial's surface.
 
            @arg x_xyz: X component (C{scalar}) or a cartesian (C{Cartesian},
                        L{Ecef9Tuple}, L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
            @kwarg y: Y component (C{scalar}), required if B{C{x_xyz}} is C{scalar},
                        ignored otherwise.
            @kwarg z: Z component (C{scalar}), like B{C{y}}.
-           @arg h: Height above or below this triaxial's surface (C{meter}, same units
-                   as this triaxial's semi-axes).
-           @kwarg normal: If C{True}, the height is C{normal} to the surface, otherwise
-                          C{radially} to the center of this triaxial (C{bool}).
-           @kwarg eps: Tolerance for on-surface test (C{scalar}), see method L{Triaxial.sideOf}.
+           @kwarg height: Height above or below this triaxial's surface (C{meter}, same
+                          units as this triaxial's semi-axes).
+           @kwarg normal: If C{True}, B{C{height}} is C{perpendicular} to the surface,
+                          otherwise C{radial} to the center of this triaxial (C{bool}).
+           @kwarg eps: Tolerance for on-surface test (C{scalar}), see method
+                       L{Triaxial.sideOf}.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{Vector3Tuple}C{(x, y, z)}.
 
-           @raise TrialError: Cartesian C{(x, y, z)} not on this triaxial's surface.
+           @raise TrialError: Cartesian B{C{x_xyz}} or C{(x, y, z)} not on this triaxial's
+                              surface.
 
            @see: Methods L{Triaxial.forwardCartesian} and L{Triaxial.height4}.
         '''
+        h, name = _xkwds_pop2(name, h=height)  # h=height for backward compatibility
         v = _otherV3d_(x_xyz, y, z, **name)
-        s =  self.sideOf(v.xyz, eps=eps)
-        if s:  # PYCHOK no cover
-            t = _SPACE_((_inside_ if s < 0 else _outside_), self.toRepr())
-            raise TriaxialError(eps=eps, sideOf=s, x=v.x, y=v.y, z=v.z, txt=t)
-
+        _ =  self._sideOn(v, eps=eps)
+        h = _HeightINT0(h)
         if h:
             if normal:
                 v = v.plus(self.normal3d(*v.xyz, length=h))
@@ -988,7 +447,7 @@ class Triaxial(Triaxial_):
                     as this triaxial's semi-axes.
 
            @see: Methods L{Triaxial.forwardLatLon} and L{Triaxial.forwardLatLon_}
-                 and U{expressions (4-5)<https://www.Topo.Auth.GR/wp-content/uploads/
+                 and U{equations (4-5)<https://OLD.Topo.Auth.GR/wp-content/uploads/
                  sites/111/2021/12/09_Panou.pdf>}.
         '''
         v = _otherV3d_(x_xyz, y, z)
@@ -996,14 +455,40 @@ class Triaxial(Triaxial_):
                       self._c2_b2,  # == 1 - e_sub_y**2
                      _1_0)
         a, b, h = _reverseLatLon3(s, atan2d, v, self.forwardLatLon_)
-        return LatLon3Tuple(Degrees(lat=a), Degrees(lon=b), h, **name)
+        return LatLon3Tuple(Lat(a), Lon(b), h, **name)
 
 
-class ConformalTriaxial(Triaxial):
-    '''This is a I{Jacobi Conformal} projection of a triaxial ellipsoid to a plane
-       where the C{X} and C{Y} grid lines are straight.
+class TriaxialB(_Triaxial3Base):
+    '''I{Ordered} triaxial ellipsoid specified by its middle semi-axis and shape.
 
-       Ellipsoidal coordinates I{beta} and I{omega} are converted to Jacobi Conformal
+       @see: L{Triaxial} for details and more information.
+    '''
+    def __init__(self, b, e2=_0_0, k2=_1_0, kp2=_0_0, **name):
+        '''New L{TriaxialB} triaxial.
+
+           @arg b: Middle semi-axis (C{meter}, conventionally).
+           @kwarg e2: Excentricty I{squared} (C{scalar, e2 = (a**2 - c**2) / B{b}**2}).
+           @kwarg k2: Oblateness I{squared} (C{scalar, k2 = (C{b}**2 - c**2) / (a**2 - c**2)}).
+           @kwarg kp2: Prolateness I{squared} (C{scalar, kp2 = (a**2 - C{b}**2) / (a**2 - c**2)}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
+
+           @note: The semi-axes must be ordered as C{B{a} >= B{b} >= B{c} > 0} but
+                  may be spherical, C{B{e2} == 0}, i.e. C{B{a} == B{c}}.  In that case
+                  C{B{k2} == 0} represents a I{prolate sphere}, C{B{k2} == 1} an
+                  I{oblate sphere}, otherwise a I{triaxial sphere} with C{0 < B{k2} < 1}.
+
+           @note: The B{C{k2}} and B{C{kp2}} arguments are normalized, C{B{k2} + B{kp2} == 1}.
+
+           @raise TriaxialError: Semi-axes unordered or invalid.
+        '''
+        self._init_abc3_e2_k2_kp2(Radius_(b=b), e2, k2, kp2, **name)
+
+
+class Conformal(Triaxial):
+    '''This is a I{Jacobi Conformal} projection of a triaxial ellipsoid to a plane where
+       the C{X} and C{Y} grid lines are straight.
+
+       I{Ellipsoidal} coordinates I{beta} and I{omega} are converted to Jacobi Conformal
        I{y} respectively I{x} separately.  Jacobi's coordinates have been multiplied
        by C{sqrt(B{a}**2 - B{c}**2) / (2 * B{b})} so that the customary results are
        returned in the case of an ellipsoid of revolution.
@@ -1020,6 +505,34 @@ class ConformalTriaxial(Triaxial):
              C. G. J. I{U{Vorlesungen über Dynamik<https://Books.Google.com/books?
              id=ryEOAAAAQAAJ&pg=PA212>}}, page 212ff.
     '''
+    if _FOR_DOCS:
+        __init__ = Triaxial.__init__
+
+    @Property_RO
+    def _a2_b(self):
+        return self._a2_b2 * self.b
+
+    @Property_RO
+    def _c2_b(self):
+        return self._c2_b2 * self.b
+
+    def x(self, omega, unit=Radians):
+        '''Compute a I{Jacobi Conformal} C{x} projection.
+
+           @arg omega: Ellipsoidal longitude (C{Ang} or B{C{unit}}).
+           @kwarg unit: Unit of scalar B{C{omega}} (or C{Degrees}).
+
+           @return: The C{x} projection (L{Meter}), same units as
+                    this triaxial's semi-axes.
+        '''
+        s, c = _SinCos2(omega, unit)
+        return Meter(x=self._x(s, c, self._a2_b))
+
+    def _x(self, s, c, a2_b_):
+        '''(INTERNAL) Helper for C{.x}, C{.xR_} and C{.xy}.
+        '''
+        s, c = self._norm2(s, c, self.a)
+        return self._xE.fPi(s, c) * a2_b_
 
     @Property_RO
     def _xE(self):
@@ -1029,14 +542,15 @@ class ConformalTriaxial(Triaxial):
         # -a2b2 / b2 == (b2 - a2) / b2 == 1 - a2 / b2 == 1 - a2_b2
         return self._Elliptic(k2, _1_0 - self._a2_b2, kp2, self._a2_b2)
 
-    def xR(self, omega):
+    def xR(self, omega, unit=Radians):
         '''Compute a I{Jacobi Conformal} C{x} projection.
 
-           @arg omega: Ellipsoidal longitude (C{radians} or L{Degrees}).
+           @arg omega: Ellipsoidal longitude (C{Ang} or B{C{unit}}).
+           @kwarg unit: Unit of scalar B{C{omega}} (or C{Degrees}).
 
            @return: The C{x} projection (L{Radians}).
         '''
-        return self.xR_(*SinCos2(omega))
+        return self.xR_(*_SinCos2(omega, unit))
 
     def xR_(self, somega, comega):
         '''Compute a I{Jacobi Conformal} C{x} projection.
@@ -1046,28 +560,55 @@ class ConformalTriaxial(Triaxial):
 
            @return: The C{x} projection (L{Radians}).
         '''
-        s, c = self._norm2(somega, comega, self.a)
-        return Radians(x=self._xE.fPi(s, c) * self._a2_b2)
+        return Radians(x=self._x(somega, comega, self._a2_b2))
+
+    def xy(self, beta, omega, **unit_name):
+        '''Compute a I{Jacobi Conformal} C{x} and C{y} projection.
+
+           @arg beta: Ellipsoidal latitude (C{Ang} or B{C{unit}}).
+           @arg omega: Ellipsoidal longitude (C{Ang} or B{C{unit}}).
+           @kwarg unit_name: Optional scalar C{B{unit}=}L{Radians} and
+                       name (C{str}), overriding C{B{name}="xyR2"}.
+
+           @return: A (L{Vector2Tuple}C{(x, y)}), both in C{Meter},
+                    same units as this triaxial's semi-axes..
+        '''
+        unit, name = _xkwds_pop2(unit_name, unit=Radians)
+        return Vector2Tuple(self.x(omega, unit=unit),
+                            self.y(beta,  unit=unit),
+                            name=_name__(name, name__=self.xy))
 
     @Property_RO
     def xyQ2(self):
-        '''Get the I{Jacobi Conformal} quadrant size (L{Conformal2Tuple}C{(x, y)}).
+        '''Get the I{Jacobi Conformal} quadrant size in C{meter}
+           (L{Vector2Tuple}C{(x, y)}).
+        '''
+        return Vector2Tuple(Meter(x=self._a2_b * self._xE.cPi),
+                            Meter(y=self._c2_b * self._yE.cPi),
+                            name=Conformal.xyQ2.name)
+
+    @Property_RO
+    def xyQR2(self):
+        '''Get the I{Jacobi Conformal} quadrant size in C{Radians}
+           (L{Conformal2Tuple}C{(x, y)}).
         '''
         return Conformal2Tuple(Radians(x=self._a2_b2 * self._xE.cPi),
                                Radians(y=self._c2_b2 * self._yE.cPi),
-                               name=ConformalTriaxial.xyQ2.name)
+                               name=Conformal.xyQR2.name)
 
-    def xyR2(self, beta, omega, **name):
+    def xyR2(self, beta, omega, **unit_name):
         '''Compute a I{Jacobi Conformal} C{x} and C{y} projection.
 
-           @arg beta: Ellipsoidal latitude (C{radians} or L{Degrees}).
-           @arg omega: Ellipsoidal longitude (C{radians} or L{Degrees}).
-           @kwarg name: Optional name (C{str}), overriding C{B{name}="xyR2"}.
+           @arg beta: Ellipsoidal latitude (C{Ang} or B{C{unit}}).
+           @arg omega: Ellipsoidal longitude (C{Ang} or B{C{unit}}).
+           @kwarg unit_name: Optional scalar C{B{unit}=}L{Radians} and
+                       name (C{str}), overriding C{B{name}="xyR2"}.
 
-           @return: A L{Conformal2Tuple}C{(x, y)}.
+           @return: A L{Conformal2Tuple}C{(x, y)}, both in C{Radians}.
         '''
-        return self.xyR2_(*(SinCos2(beta) + SinCos2(omega)),
-                          name=_name__(name, name__=self.xyR2))
+        unit, name  = _xkwds_pop2(unit_name, unit=Radians)
+        sb_cb_so_co = _SinCos2(beta, unit) + _SinCos2(omega, unit)
+        return self.xyR2_(*sb_cb_so_co, name=_name__(name, name__=self.xyR2))
 
     def xyR2_(self, sbeta, cbeta, somega, comega, **name):
         '''Compute a I{Jacobi Conformal} C{x} and C{y} projection.
@@ -1084,22 +625,41 @@ class ConformalTriaxial(Triaxial):
                                self.yR_(sbeta,  cbeta),
                                name=_name__(name, name__=self.xyR2_))
 
+    def y(self, beta, unit=Radians):
+        '''Compute a I{Jacobi Conformal} C{y} projection.
+
+           @arg beta: Ellipsoidal latitude (C{Ang} or B{C{unit}}).
+           @kwarg unit: Unit of scalar B{C{beta}} (or C{Degrees}).
+
+           @return: The C{y} projection (L{Meter}), same units as
+                    this triaxial's semi-axes.
+        '''
+        s, c = _SinCos2(beta, unit)
+        return Meter(y=self._y(s, c, self._c2_b))
+
+    def _y(self, s, c, c2_b_):
+        '''(INTERNAL) Helper for C{.y}, C{.yR_} and C{.xy}.
+        '''
+        s, c = self._norm2(s, c, self.c)
+        return self._yE.fPi(s, c) * c2_b_
+
     @Property_RO
     def _yE(self):
         '''(INTERNAL) Get the y-elliptic function.
         '''
-        kp2, k2 = self._k2E_kp2E  # swapped!
+        k2, kp2 = self._k2E_kp2E
         # b2c2 / b2 == (b2 - c2) / b2 == 1 - c2 / b2 == e2bc
-        return self._Elliptic(k2, self.e2bc, kp2, self._c2_b2)
+        return self._Elliptic(kp2, self.e2bc, k2, self._c2_b2)
 
-    def yR(self, beta):
+    def yR(self, beta, unit=Radians):
         '''Compute a I{Jacobi Conformal} C{y} projection.
 
-           @arg beta: Ellipsoidal latitude (C{radians} or L{Degrees}).
+           @arg beta: Ellipsoidal latitude (C{Ang} or B{C{unit}}).
+           @kwarg unit: Unit of scalar B{C{beta}} (or C{Degrees}).
 
            @return: The C{y} projection (L{Radians}).
         '''
-        return self.yR_(*SinCos2(beta))
+        return self.yR_(*_SinCos2(beta, unit))
 
     def yR_(self, sbeta, cbeta):
         '''Compute a I{Jacobi Conformal} C{y} projection.
@@ -1109,40 +669,36 @@ class ConformalTriaxial(Triaxial):
 
            @return: The C{y} projection (L{Radians}).
         '''
-        s, c = self._norm2(sbeta, cbeta, self.c)
-        return Radians(y=self._yE.fPi(s, c) * self._c2_b2)
+        return Radians(y=self._y(sbeta, cbeta, self._c2_b2))
 
 
-class ConformalSphere(ConformalTriaxial):
-    '''An alternate, I{spherical Jacobi Conformal} projection.
+class ConformalSphere(Conformal):
+    '''Alternate, I{Jacobi Conformal projection} on a I{spherical} triaxial.
 
-       @see: L{ConformalTriaxial} for other and more details.
+       @see: L{Conformal<triaxials.triaxial5.Conformal>} for more information.
     '''
     _ab = _bc = 0
 
-    def __init__(self, radius_triaxial, ab=0, bc=0, **name):
+    def __init__(self, radius_conformal, ab=0, bc=0, **name):
         '''New L{ConformalSphere}.
 
-           @arg radius_triaxial: Radius (C{scalar}, conventionally in
-                       C{meter}) or an other L{ConformalSphere},
-                       L{ConformalTriaxial} or ordered L{Triaxial}.
-           @kwarg ab: Relative magnitude of C{B{a} - B{b}} (C{meter},
-                      same units as C{scalar B{radius}}.
-           @kwarg bc: Relative magnitude of C{B{b} - B{c}} (C{meter},
-                      same units as C{scalar B{radius}}.
+           @arg radius_conformal: Radius (C{scalar}, conventionally in C{meter})
+                       or an other L{ConformalSphere} or L{Conformal}.
+           @kwarg ab: Relative magnitude of C{B{a} - B{b}} (C{meter}, same units
+                      as C{scalar B{radius}}.
+           @kwarg bc: Relative magnitude of C{B{b} - B{c}} (C{meter}, same units
+                      as C{scalar B{radius}}.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-           @raise TriaxialError: Invalid B{C{radius_triaxial}}, negative
-                                 B{C{ab}}, negative B{C{bc}} or C{(B{ab}
-                                 + B{bc})} not positive.
+           @raise TriaxialError: Invalid B{C{radius_conformal}}, negative B{C{ab}},
+                                 negative B{C{bc}} or C{(B{ab} + B{bc})} not positive.
 
-           @note: If B{C{radius_triaxial}} is a L{ConformalSphere}
-                  and if B{C{ab}} and B{C{bc}} are both zero or C{None},
-                  the B{C{radius_triaxial}}'s C{ab}, C{bc}, C{a}, C{b}
-                  and C{c} are copied.
+           @note: If B{C{radius_conformal}} is a L{ConformalSphere} and if B{C{ab}}
+                  and B{C{bc}} are both zero or C{None}, the B{C{radius_conformal}}'s
+                  C{ab}, C{bc}, C{a}, C{b} and C{c} are copied.
         '''
         try:
-            r = radius_triaxial
+            r = radius_conformal
             if isinstance(r, Triaxial):  # ordered only
                 t = r._abc3
                 j = isinstance(r, ConformalSphere) and not bool(ab or bc)
@@ -1158,7 +714,7 @@ class ConformalSphere(ConformalTriaxial):
                            and _isfinite(self._a2c2)):
                 raise ValueError(_not_(_finite_))
         except (TypeError, ValueError) as x:
-            raise TriaxialError(radius_triaxial=r, ab=ab, bc=bc, cause=x)
+            raise TriaxialError(radius=r, ab=ab, bc=bc, cause=x)
         if name:
             self.name = name
 
@@ -1201,12 +757,6 @@ class ConformalSphere(ConformalTriaxial):
         return self.a
 
 
-class TriaxialError(_ValueError):
-    '''Raised for L{Triaxial} issues.
-    '''
-    pass  # ...
-
-
 class Triaxials(_NamedEnum):
     '''(INTERNAL) L{Triaxial} registry, I{must} be a sub-class
        to accommodate the L{_LazyNamedEnumItem} properties.
@@ -1222,33 +772,26 @@ Triaxials = Triaxials(Triaxial, Triaxial_)  # PYCHOK singleton
 # <https://ArxIV.org/pdf/1909.06452.pdf> Table 1 Semi-axes in Km
 # <https://www.JPS.NASA.gov/education/images/pdf/ss-moons.pdf>
 # <https://link.Springer.com/article/10.1007/s00190-022-01650-9>
+# <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1Constants.html>
 _abc84_35 = (_EWGS84.a + 35), (_EWGS84.a - 35), _EWGS84.b
-Triaxials._assert(                 # a (Km)       b (Km)     c (Km)     planet
-    Amalthea  = _lazy('Amalthea',  125.0,        73.0,     _64_0),    # Jupiter
-    Ariel     = _lazy('Ariel',     581.1,       577.9,     577.7),    # Uranus
-    Earth     = _lazy('Earth',    6378.173435, 6378.1039, 6356.7544),
-    Enceladus = _lazy('Enceladus', 256.6,       251.4,     248.3),    # Saturn
-    Europa    = _lazy('Europa',   1564.13,     1561.23,   1560.93),   # Jupiter
-    Io        = _lazy('Io',       1829.4,      1819.3,    1815.7),    # Jupiter
-    Mars      = _lazy('Mars',     3394.6,      3393.3,    3376.3),
-    Mimas     = _lazy('Mimas',     207.4,       196.8,     190.6),    # Saturn
-    Miranda   = _lazy('Miranda',   240.4,       234.2,     232.9),    # Uranus
-    Moon      = _lazy('Moon',     1735.55,     1735.324,  1734.898),  # Earth
-    Tethys    = _lazy('Tethys',    535.6,       528.2,     525.8),    # Saturn
+Triaxials._assert(                 # a (Km)       b (Km)      c (Km)       planet
+    Amalthea  = _lazy('Amalthea',  125.0,        73.0,      _64_0),      # Jupiter
+    Ariel     = _lazy('Ariel',     581.1,       577.9,      577.7),      # Uranus
+    Earth     = _lazy('Earth',    6378.173435, 6378.1039,  6356.7544),
+    Enceladus = _lazy('Enceladus', 256.6,       251.4,      248.3),      # Saturn
+    Europa    = _lazy('Europa',   1564.13,     1561.23,    1560.93),     # Jupiter
+    Io        = _lazy('Io',       1829.4,      1819.3,     1815.7),      # Jupiter
+    Mars      = _lazy('Mars',     3394.6,      3393.3,     3376.3),
+    Mimas     = _lazy('Mimas',     207.4,       196.8,      190.6),      # Saturn
+    Miranda   = _lazy('Miranda',   240.4,       234.2,      232.9),      # Uranus
+    Moon      = _lazy('Moon',     1735.55,     1735.324,   1734.898),    # Earth
+    Tethys    = _lazy('Tethys',    535.6,       528.2,      525.8),      # Saturn
+    WGS84_3   = _lazy('WGS84_3',  6378.17136,  6378.10161, 6356.75184),  # C++
+    WGS84_3r  = _lazy('WGS84_3r', 6378.172,    6378.102,   6356.752),    # C++, rounded
     WGS84_35  = _lazy('WGS84_35', *map(m2km, _abc84_35)))
 del _abc84_35, _EWGS84
 
 
-def _getitems(items, *indices):
-    '''(INTERNAL) Get the C{items} at the given I{indices}.
-
-       @return: C{Type(items[i] for i in indices)} with
-                C{Type = type(items)}, any C{type} having
-                the special method C{__getitem__}.
-    '''
-    return type(items)(map(items.__getitem__, indices))
-
-
 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.
@@ -1314,7 +857,7 @@ def hartzell4(pov, los=False, tri_biax=_WGS84, **name):
        @kwarg los: Line-Of-Sight, I{direction} to the tri-/biaxial (L{Los}, L{Vector3d})
                    or C{True} for the I{normal, perpendicular, plumb} to the surface of
                    the tri-/biaxial or C{False} or C{None} to point to its center.
-       @kwarg tri_biax: A triaxial (L{Triaxial}, L{Triaxial_}, L{ConformalTriaxial} or
+       @kwarg tri_biax: A triaxial (L{Triaxial}, L{Triaxial_}, L{Conformal} or
                         L{ConformalSphere}) or biaxial ellipsoid (L{Datum},
                         L{Ellipsoid}, L{Ellipsoid2}, L{a_f2Tuple}) or spherical earth
                         radius (C{scalar}, conventionally in C{meter}).
@@ -1335,12 +878,7 @@ def hartzell4(pov, los=False, tri_biax=_WGS84, **name):
              Line-of-Sight Intersection with Earth"<https://StephenHartzell.Medium.com/
              satellite-line-of-sight-intersection-with-earth-d786b4a6a9b6>}.
     '''
-    if isinstance(tri_biax, Triaxial_):
-        T = tri_biax
-    else:
-        D = tri_biax if isinstance(tri_biax, Datum) else \
-                  _spherical_datum(tri_biax, name__=hartzell4)  # typename
-        T = D.ellipsoid._triaxial
+    T = _tri_biaxial(tri_biax, hartzell4)
     try:
         v, h, i = _hartzell3(pov, los, T)
     except Exception as x:
@@ -1349,11 +887,58 @@ def hartzell4(pov, los=False, tri_biax=_WGS84, **name):
     return Vector4Tuple(v.x, v.y, v.z, h, iteration=i, name=n)
 
 
-def _hypot2_1(x, y, z=0):
-    '''(INTERNAL) Compute M{x**2 + y**2 + z**2 - 1} with C{max(fabs(x), fabs(y),
-       fabs(z))} rarely greater than 1.0.
+def height4(x_xyz, y=None, z=None, tri_biax=_WGS84, normal=True, eps=EPS, **name):
+    '''Compute the projection on and the height above or below a tri-/biaxial ellipsoid's surface.
+
+       @arg x_xyz: X component (C{scalar}) or a cartesian (C{Cartesian}, L{Ecef9Tuple},
+                   L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
+       @kwarg y: Y component (C{scalar}), required if B{C{x_xyz}} if C{scalar}, ignored
+                 otherwise.
+       @kwarg z: Z component (C{scalar}), like B{C{y}}.
+       @kwarg normal: If C{True}, the projection is the I{perpendicular, plumb} to the
+                      tri-/biaxial's surface, otherwise the C{radial} line to the center
+                      of the tri-/biaxial (C{bool}).
+       @kwarg eps: Tolerance for root finding and validation (C{scalar}), use a negative
+                   value to skip validation.
+       @kwarg name: Optional C{B{name}="height4"} (C{str}).
+
+       @return: L{Vector4Tuple}C{(x, y, z, h)} with the cartesian coordinates C{x}, C{y}
+                and C{z} of the projection on or the intersection with and with the height
+                C{h} above or below the tri-/biaxial's surface in C{meter}, conventionally.
+
+       @raise TriaxialError: Non-cartesian B{C{xyz}}, invalid B{C{eps}}, no convergence in
+              root finding or validation failed.
+
+       @see: Methods L{Triaxial.normal3d} and L{Ellipsoid.height4}, I{Eberly}'s U{Distance from a Point to ...
+             <https://www.GeometricTools.com/Documentation/DistancePointEllipseEllipsoid.pdf>} and I{Bektas}'
+             U{Shortest Distance from a Point to Triaxial Ellipsoid<https://www.ResearchGate.net/publication/
+             272149005_SHORTEST_DISTANCE_FROM_A_POINT_TO_TRIAXIAL_ELLIPSOID>}.
     '''
-    return fsumf_(_N_1_0, x*x, y*y, z*z)
+    v = _otherV3d_(x_xyz, y, z)
+    T = _tri_biaxial(tri_biax, height4)
+    r =  T.isSpherical
+
+    i, h = None, v.length
+    if h < EPS0:  # EPS
+        x = y = z = _0_0
+        h -= min(T._abc3)  # nearest
+    elif r:  # .isSpherical
+        x, y, z = v.times(r / h).xyz3
+        h -= r
+    else:
+        x, y, z = v.xyz3
+        try:
+            if normal:  # plumb to surface
+                x, y, z, h, i = _plumbTo5(x, y, z, T, eps=eps)
+            else:  # radial to center
+                x, y, z = T._radialTo3(z, hypot(x, y), y, x)
+                h = v.minus_(x, y, z).length
+        except Exception as e:
+            raise TriaxialError(x=x, y=y, z=z, cause=e)
+        if h > 0 and T.sideOf(v, eps=EPS0) < 0:
+            h = -h  # inside
+    n = _name__(name, name__=height4)  # typename
+    return Vector4Tuple(x, y, z, h, iteration=i, name=n)
 
 
 def _ordered(a, b, c):
@@ -1363,27 +948,8 @@ def _ordered(a, b, c):
         raise TriaxialError(a=a, b=b, c=c, txt=_not_ordered_)
 
 
-def _otherV3d_(x_xyz, y, z, **name):
-    '''(INTERNAL) Get a Vector3d from C{x_xyz}, C{y} and C{z}.
-    '''
-    return Vector3d(x_xyz, y, z, **name) if isscalar(x_xyz) else \
-          _otherV3d(x_xyz=x_xyz, **name)
-
-
-def _over0(p, q):
-    '''(INTERNAL) Return C{p / q} or C{0}.
-    '''
-    return (p / q) if q > fabs(p) else _0_0
-
-
-def _over02(p, q):
-    '''(INTERNAL) Return C{(p / q)**2} or C{0}.
-    '''
-    return (p / q)**2 if p and q else _0_0
-
-
 def _plumbTo3(px, py, E, eps=EPS):  # in .ellipsoids.Ellipsoid.height4
-    '''(INTERNAL) Nearest point on a 2-D ellipse in 1st quadrant.
+    '''(INTERNAL) Nearest point in 1st quadrant on a 2-D ellipse.
     '''
     a, b = E.a, E.b
     if min(px, py, a, b) < EPS0:
@@ -1548,8 +1114,8 @@ def _reverseLatLon3(s, atan2_, v, forward_):
     d = hypot( x, y)
     a = atan2_(z, d)
     b = atan2_(y, x)
-    h = v.minus_(*forward_(z, d, y, x)).length or INT0
-    return a, b, h
+    h = v.minus_(*forward_(z, d, y, x)).length
+    return a, b, (h or INT0)
 
 
 def _rootNd(r, s, u, v, w, g, eps=EPS0):
@@ -1584,10 +1150,16 @@ def _rootNd(r, s, u, v, w, g, eps=EPS0):
     return t, i
 
 
-def _sqrt0(x):
-    '''(INTERNAL) C{sqrt0} with C{TriaxialError}.
+def _tri_biaxial(tri_biax, where):
+    '''(INTERNAL) Get a triaxail for C{tri_biax}.
     '''
-    return sqrt0(x, Error=TriaxialError)
+    if isinstance(tri_biax, _UnOrderedTriaxialBase):
+        T = tri_biax
+    else:
+        D = tri_biax if isinstance(tri_biax, Datum) else \
+                  _spherical_datum(tri_biax, name__=where)  # typename
+        T = D.ellipsoid._triaxial
+    return T
 
 
 def _validate(a, b, c, d, T, x, y, z, val):
@@ -1613,8 +1185,8 @@ if __name__ == _DMAIN_:
     from pygeodesy import printf
     from pygeodesy.interns import _COMMA_, _NL_, _NLATvar_
 
-    t = Triaxial_(6378388.0, 6378318.0, 6356911.9461)
-    t = t.height4(3909863.9271, 3909778.123, 3170932.5016)
+    T = Triaxial_(6378388.0, 6378318.0, 6356911.9461)
+    t = T.height4(3909863.9271, 3909778.123, 3170932.5016)
     printf('# Bektas: %r', t)
 
     # __doc__ of this file, force all into registery
@@ -1627,7 +1199,7 @@ if __name__ == _DMAIN_:
 
 # **) MIT License
 #
-# Copyright (C) 2022-2025 -- mrJean1 at Gmail -- All Rights Reserved.
+# Copyright (C) 2022-2026 -- 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"),