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

pygeodesy/ellipsoidalBaseDI.py

@@ -7,7 +7,7 @@ class C{LatLonEllipsoidalBaseDI} and functions.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import isLatLon, issubclassof, map2
+from pygeodesy.basics import isLatLon, _xsubclassof
 from pygeodesy.constants import EPS, MAX, PI, PI2, PI_4, isnear0, isnear1, \
                                _EPSqrt as _TOL, _0_0, _0_5, _1_5, _3_0
 # from pygeodesy.dms import F_DMS  # _MODS
@@ -20,8 +20,7 @@ from pygeodesy.formy import _isequalTo, opposing, _radical2
 from pygeodesy.interns import _antipodal_, _concentric_, _ellipsoidal_, \
                               _exceed_PI_radians_, _low_, _near_, \
                               _SPACE_, _too_
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, \
-                             _dunder_nameof
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.namedTuples import Bearing2Tuple, Destination2Tuple, \
                                   Intersection3Tuple, NearestOn2Tuple, \
                                   NearestOn8Tuple, _LL4Tuple
@@ -35,7 +34,7 @@ from pygeodesy.utily import m2km, unroll180, _unrollon, _unrollon3, \
 from math import degrees, radians
 
 __all__ = _ALL_LAZY.ellipsoidalBaseDI
-__version__ = '24.05.19'
+__version__ = '24.06.17'
 
 _polar__  = 'polar?'
 _B2END    = _1_5  # _intersect3 bearing to pseudo-end point factor
@@ -111,9 +110,8 @@ class LatLonEllipsoidalBaseDI(LatLonEllipsoidalBase):
     def _Direct(self, distance, bearing, LL, height):  # overloaded by I{Vincenty}
         '''(INTERNAL) I{Karney}'s C{Direct} method.
 
-           @return: A L{Destination2Tuple}C{(destination, final)} or
-                    a L{Destination3Tuple}C{(lat, lon, final)} if
-                    B{C{LL}} is C{None}.
+           @return: A L{Destination2Tuple}C{(destination, final)} or a
+                    L{Destination3Tuple}C{(lat, lon, final)} if C{B{LL} is None}.
         '''
         g = self.geodesic
         r = g.Direct3(self.lat, self.lon, bearing, distance)
@@ -337,17 +335,17 @@ class LatLonEllipsoidalBaseDI(LatLonEllipsoidalBase):
 
            @arg points: The path or polygon points (C{LatLon}[]).
            @kwarg closed: Optionally, close the polygon (C{bool}).
-           @kwarg height: Optional height, overriding the height of this and
-                          all other points (C{meter}, conventionally).  If
-                          B{C{height}} is C{None}, the height of each point
-                          is taken into account for distances.
-           @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                        B{C{points}} (C{bool}).
-
-           @return: A L{NearestOn8Tuple}C{(closest, distance, fi, j, start,
-                    end, initial, final)} with C{distance} in C{meter},
-                    conventionally and with the C{closest}, the C{start}
-                    the C{end} point each an instance of this C{LatLon}.
+           @kwarg height: Optional height, overriding the height of this and all
+                          other points (C{meter}, conventionally).  If C{B{height}
+                          is None}, each point's height is taken into account to
+                          compute distances.
+           @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}}
+                        (C{bool}).
+
+           @return: A L{NearestOn8Tuple}C{(closest, distance, fi, j, start, end,
+                    initial, final)} with C{distance} in C{meter}, conventionally
+                    and with the C{closest}, the C{start} the C{end} point each
+                    an instance of this C{LatLon}.
 
            @raise PointsError: Insufficient number of B{C{points}}.
 
@@ -422,7 +420,7 @@ class LatLonEllipsoidalBaseDI(LatLonEllipsoidalBase):
                           conventionally) or C{None} for an interpolated height.
            @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{point}}
                         and/or B{C{other}} (C{bool}).
-           @kwarg tol: Convergence tolerance (C{scalar}).
+           @kwarg tol: Convergence tolerance (C{meter}).
 
            @return: The intersection point, an instance of this C{LatLon}.
 
@@ -572,10 +570,8 @@ def _Equidistant00(equidistant, p1):
     if equidistant is None or not callable(equidistant):
         equidistant = p1.Equidistant
     else:
-        Eqs = _MODS.azimuthal._Equidistants
-        if not issubclassof(equidistant, *Eqs):  # PYCHOK no cover
-            t = map2(_dunder_nameof, Eqs)
-            raise _IsnotError(*t, equidistant=equidistant)
+        _xsubclassof(*_MODS.azimuthal._Equidistants,
+                           equidistant=equidistant)
     return equidistant(0, 0, p1.datum)
 
 

pygeodesy/ellipsoidalExact.py

@@ -24,7 +24,7 @@ from pygeodesy.points import _areaError, ispolar  # PYCHOK exported
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalExact
-__version__ = '22.02.18'
+__version__ = '24.06.11'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -39,7 +39,7 @@ class Cartesian(CartesianEllipsoidalBase):
                              B{datum}=...} to override this L{LatLon} class
                              or specify C{B{LatLon}=None}.
 
-           @return: The geodetic point (L{LatLon}) or if B{C{LatLon}} is C{None},
+           @return: The geodetic point (L{LatLon}) or if C{B{LatLon} is None},
                     an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
                     with C{C} and C{M} if available.
 
@@ -78,7 +78,7 @@ class LatLon(LatLonEllipsoidalBaseDI):
                             L{Cartesian} class or set C{B{Cartesian}=None}.
 
            @return: The cartesian (ECEF) coordinates as (L{Cartesian}) or if
-                    B{C{Cartesian}} is C{None}, an L{Ecef9Tuple}C{(x, y, z, lat,
+                    C{B{Cartesian} is None}, an L{Ecef9Tuple}C{(x, y, z, lat,
                     lon, height, C, M, datum)} with C{C} and C{M} if available.
 
            @raise TypeError: Invalid B{C{Cartesian}}, B{C{datum}} or other

pygeodesy/ellipsoidalGeodSolve.py

@@ -24,7 +24,7 @@ from pygeodesy.points import _areaError, ispolar  # PYCHOK exported
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalGeodSolve
-__version__ = '24.05.25'
+__version__ = '24.06.11'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -39,7 +39,7 @@ class Cartesian(CartesianEllipsoidalBase):
                                    B{datum}=...} to override this L{LatLon}
                                    class or specify C{B{LatLon}=None}.
 
-           @return: The geodetic point (L{LatLon}) or if B{C{LatLon}} is C{None},
+           @return: The geodetic point (L{LatLon}) or if C{B{LatLon} is None},
                     an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
                     with C{C} and C{M} if available.
 
@@ -73,18 +73,15 @@ class LatLon(LatLonEllipsoidalBaseDI):
     def toCartesian(self, **Cartesian_datum_kwds):  # PYCHOK Cartesian=Cartesian, datum=None
         '''Convert this point to exact cartesian (ECEF) coordinates.
 
-           @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}}
-                  and other keyword arguments, ignored if C{B{Cartesian} is None}.
-                  Use C{B{Cartesian}=...} to override this L{Cartesian} class
-                  or set C{B{Cartesian}=None}.
+           @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}} and other keyword
+                  arguments, ignored if C{B{Cartesian} is None}.  Use C{B{Cartesian}=Class}
+                  to override this L{Cartesian} class or set C{B{Cartesian}=None}.
 
-           @return: The cartesian (ECEF) coordinates (L{Cartesian}) or if
-                    B{C{Cartesian}} is C{None}, an L{Ecef9Tuple}C{(x, y, z,
-                    lat, lon, height, C, M, datum)} with C{C} and C{M} if
-                    available.
+           @return: The cartesian (ECEF) coordinates (L{Cartesian}) or if C{B{Cartesian} is
+                    None}, an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
+                    C{C} and C{M} if available.
 
-           @raise TypeError: Invalid B{C{Cartesian}}, B{C{datum}} or other
-                             B{C{Cartesian_datum_kwds}}.
+           @raise TypeError: Invalid B{C{Cartesian}}, B{C{datum}} or other B{C{Cartesian_datum_kwds}}.
         '''
         kwds = _xkwds(Cartesian_datum_kwds, Cartesian=Cartesian, datum=self.datum)
         return LatLonEllipsoidalBaseDI.toCartesian(self, **kwds)
@@ -93,25 +90,20 @@ class LatLon(LatLonEllipsoidalBaseDI):
 def areaOf(points, datum=_WGS84, wrap=True):
     '''Compute the area of an (ellipsoidal) polygon or composite.
 
-       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or
-                    L{BooleanGH}).
+       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
 
-       @return: Area (C{meter}, same as units of the B{C{datum}}'s
-                ellipsoid axes, I{squared}).
+       @return: Area (C{meter}, same as units of the B{C{datum}}'s ellipsoid axes, I{squared}).
 
        @raise PointsError: Insufficient number of B{C{points}}.
 
        @raise TypeError: Some B{C{points}} are not L{LatLon}.
 
-       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled
-                          longitudes not supported.
+       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled longitudes not supported.
 
-       @see: Functions L{pygeodesy.areaOf}, L{ellipsoidalExact.areaOf},
-             L{ellipsoidalKarney.areaOf}, L{sphericalNvector.areaOf}
-             and L{sphericalTrigonometry.areaOf}.
+       @see: Functions L{pygeodesy.areaOf}, L{ellipsoidalExact.areaOf}, L{ellipsoidalKarney.areaOf},
+             L{sphericalNvector.areaOf} and L{sphericalTrigonometry.areaOf}.
     '''
     return fabs(_polygon(datum.ellipsoid.geodsolve, points, True, False, wrap))
 

pygeodesy/ellipsoidalKarney.py

@@ -3,13 +3,12 @@
 
 u'''Ellipsoidal, I{Karney}-based geodesy.
 
-Ellipsoidal geodetic (lat-/longitude) L{LatLon} and geocentric
-(ECEF) L{Cartesian} classes and functions L{areaOf}, L{intersections2},
-L{isclockwise}, L{nearestOn} and L{perimeterOf}, all requiring I{Charles
-Karney}'s U{geographiclib <https://PyPI.org/project/geographiclib>}
-Python package to be installed.
+Ellipsoidal geodetic (lat-/longitude) L{LatLon} and geocentric (ECEF) L{Cartesian}
+classes and functions L{areaOf}, L{intersection3}, L{intersections2}, L{isclockwise},
+L{nearestOn} and L{perimeterOf}, requiring I{Charles F.F. Karney}'s U{geographiclib
+<https://PyPI.org/project/geographiclib>} Python package to be installed.
 
-Here's an example usage of C{ellipsoidalKarney}:
+A usage example of C{ellipsoidalKarney}:
 
     >>> from pygeodesy.ellipsoidalKarney import LatLon
     >>> Newport_RI = LatLon(41.49008, -71.312796)
@@ -43,25 +42,23 @@ from pygeodesy.props import deprecated_method, Property_RO
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalKarney
-__version__ = '24.05.25'
+__version__ = '24.06.11'
 
 
 class Cartesian(CartesianEllipsoidalBase):
-    '''Extended to convert C{Karney}-based L{Cartesian} to
-       C{Karney}-based L{LatLon} points.
+    '''Extended to convert C{Karney}-based L{Cartesian} to C{Karney}-based L{LatLon} points.
     '''
 
     def toLatLon(self, **LatLon_and_kwds):  # PYCHOK LatLon=LatLon, datum=None
         '''Convert this cartesian point to a C{Karney}-based geodetic point.
 
-           @kwarg LatLon_and_kwds: Optional L{LatLon} and L{LatLon} keyword
-                                   arguments as C{datum}.  Use C{B{LatLon}=...,
-                                   B{datum}=...} to override this L{LatLon}
-                                   class or specify C{B{LatLon}=None}.
+           @kwarg LatLon_and_kwds: Optional L{LatLon} and L{LatLon} keyword arguments
+                         as C{datum}.  Use C{B{LatLon}=..., B{datum}=...} to override
+                         this L{LatLon} class or specify C{B{LatLon}=None}.
 
-           @return: The geodetic point (L{LatLon}) or if B{C{LatLon}} is C{None},
-                    an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
-                    with C{C} and C{M} if available.
+           @return: The geodetic point (L{LatLon}) or if C{B{LatLon} is None}, an
+                    L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with C{C}
+                    and C{M} if available.
 
            @raise TypeError: Invalid B{C{LatLon_and_kwds}} argument.
         '''
@@ -70,13 +67,9 @@ class Cartesian(CartesianEllipsoidalBase):
 
 
 class LatLon(LatLonEllipsoidalBaseDI):
-    '''An ellipsoidal L{LatLon} similar to L{ellipsoidalVincenty.LatLon}
-       but using I{Charles F. F. Karney}'s Python U{geographiclib
-       <https://PyPI.org/project/geographiclib>} to compute geodesic
-       distances, bearings (azimuths), etc.
-
-       @note: This L{LatLon} class requires the U{geographiclib
-              <https://PyPI.org/project/geographiclib>} package.
+    '''An ellipsoidal L{LatLon} similar to L{ellipsoidalVincenty.LatLon} but using
+       I{Karney}'s Python U{geographiclib<https://PyPI.org/project/geographiclib>}
+       to compute geodesic distances, bearings (azimuths), etc.
     '''
 
     @deprecated_method
@@ -103,52 +96,41 @@ class LatLon(LatLonEllipsoidalBaseDI):
     def toCartesian(self, **Cartesian_datum_kwds):  # PYCHOK Cartesian=Cartesian, datum=None
         '''Convert this point to C{Karney}-based cartesian (ECEF) coordinates.
 
-           @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}}
-                  and other keyword arguments, ignored if C{B{Cartesian} is None}.
-                  Use C{B{Cartesian}=...} to override this L{Cartesian} class or
-                  set C{B{Cartesian}=None}.
+           @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}} and other keyword
+                  arguments, ignored if C{B{Cartesian} is None}.  Use C{B{Cartesian}=...} to
+                  override this L{Cartesian} class or set C{B{Cartesian}=None}.
 
-           @return: The cartesian (ECEF) coordinates (L{Cartesian}) or if
-                    B{C{Cartesian}} is C{None}, an L{Ecef9Tuple}C{(x, y, z,
-                    lat, lon, height, C, M, datum)} with C{C} and C{M} if
-                    available.
+           @return: The cartesian (ECEF) coordinates (L{Cartesian}) or if C{B{Cartesian} is
+                    None}, an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
+                    C{C} and C{M} if available.
 
-           @raise TypeError: Invalid B{C{Cartesian}}, B{C{datum}} or other
-                             B{C{Cartesian_datum_kwds}}.
+           @raise TypeError: Invalid B{C{Cartesian}}, B{C{datum}} or other B{C{Cartesian_datum_kwds}}.
         '''
         kwds = _xkwds(Cartesian_datum_kwds, Cartesian=Cartesian, datum=self.datum)
         return LatLonEllipsoidalBaseDI.toCartesian(self, **kwds)
 
 
 def areaOf(points, datum=_WGS84, wrap=True):
-    '''Compute the area of an (ellipsoidal) polygon or composite.
+    '''Compute the area of an (ellipsoidal) polygon or composite using I{Karney}'s
+       U{geographiclib<https://PyPI.org/project/geographiclib>} package.
 
-       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP}
-                    or L{BooleanGH}).
+       @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or L{BooleanGH}).
        @kwarg datum: Optional datum (L{Datum}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
-                    B{C{points}} (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{points}} (C{bool}).
 
-       @return: Area (C{meter}, same as units of the B{C{datum}}'s
-                ellipsoid axes, I{squared}).
+       @return: Area (C{meter}, same as units of the B{C{datum}}'s ellipsoid axes, I{squared}).
 
-       @raise ImportError: Package U{geographiclib
-                           <https://PyPI.org/project/geographiclib>}
+       @raise ImportError: Package U{geographiclib<https://PyPI.org/project/geographiclib>}
                            not installed or not found.
 
        @raise PointsError: Insufficient number of B{C{points}}.
 
        @raise TypeError: Some B{C{points}} are not L{LatLon}.
 
-       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled
-                          longitudes not supported.
-
-       @note: This function requires the U{geographiclib
-              <https://PyPI.org/project/geographiclib>} package.
+       @raise ValueError: Invalid C{B{wrap}=False}, unwrapped, unrolled longitudes not supported.
 
-       @see: Functions L{pygeodesy.areaOf}, L{ellipsoidalExact.areaOf},
-             L{ellipsoidalGeodSolve.areaOf}, L{sphericalNvector.areaOf}
-             and L{sphericalTrigonometry.areaOf}.
+       @see: Functions L{pygeodesy.areaOf}, L{ellipsoidalExact.areaOf}, L{ellipsoidalGeodSolve.areaOf},
+             L{sphericalNvector.areaOf} and L{sphericalTrigonometry.areaOf}.
 
        @note: The U{area of a polygon enclosing a pole<https://GeographicLib.SourceForge.io/
               C++/doc/classGeographicLib_1_1GeodesicExact.html#a3d7a9155e838a09a48dc14d0c3fac525>}
@@ -259,7 +241,8 @@ def intersections2(center1, radius1, center2, radius2, height=None, wrap=False,
 
 
 def isclockwise(points, datum=_WGS84, wrap=True):
-    '''Determine the direction of a path or polygon.
+    '''Determine the direction of a path or polygon using I{Karney}'s
+       U{geographiclib<https://PyPI.org/project/geographiclib>} package.
 
        @arg points: The path or polygon points (C{LatLon}[]).
        @kwarg datum: Optional datum (L{Datum}).
@@ -276,11 +259,7 @@ def isclockwise(points, datum=_WGS84, wrap=True):
 
        @raise TypeError: Some B{C{points}} are not C{LatLon}.
 
-       @raise ValueError: The B{C{points}} enclose a pole or zero
-                          area.
-
-       @note: This function requires the U{geographiclib
-              <https://PyPI.org/project/geographiclib>} package.
+       @raise ValueError: The B{C{points}} enclose a pole or zero area.
 
        @see: L{pygeodesy.isclockwise}.
     '''
@@ -340,7 +319,8 @@ def nearestOn(point, point1, point2, within=True, height=None, wrap=False,
 
 
 def perimeterOf(points, closed=False, datum=_WGS84, wrap=True):
-    '''Compute the perimeter of an (ellipsoidal) polygon or composite.
+    '''Compute the perimeter of an (ellipsoidal) polygon or composite using I{Karney}'s
+       U{geographiclib<https://PyPI.org/project/geographiclib>} package.
 
        @arg points: The polygon points (L{LatLon}[], L{BooleanFHP} or
                     L{BooleanGH}).
@@ -365,9 +345,6 @@ def perimeterOf(points, closed=False, datum=_WGS84, wrap=True):
                           longitudes not supported or C{B{closed}=False}
                           with C{B{points}} a composite.
 
-       @note: This function requires the U{geographiclib
-              <https://PyPI.org/project/geographiclib>} package.
-
        @see: Functions L{pygeodesy.perimeterOf}, L{ellipsoidalExact.perimeterOf},
              L{ellipsoidalGeodSolve.perimeterOf}, L{sphericalNvector.perimeterOf}
              and L{sphericalTrigonometry.perimeterOf}.

pygeodesy/ellipsoidalNvector.py

@@ -23,13 +23,13 @@ The Journal of Navigation (2010), vol 63, nr 3, pp 395-417.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import issubclassof, map2, _xinstanceof
+from pygeodesy.basics import issubclassof, map2, _xinstanceof, _xsubclassof
 from pygeodesy.datums import _earth_ellipsoid, _ellipsoidal_datum, _WGS84
 # from pygeodesy.dms import F_D, toDMS  # _MODS
 from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase, \
                                      _nearestOn, LatLonEllipsoidalBase, \
                                      _TOL_M,  _Wrap
-from pygeodesy.errors import _IsnotError, _xkwds, _xkwds_pop2
+from pygeodesy.errors import _xkwds, _xkwds_pop2
 # from pygeodesy.fmath import fdot  # from .nvectorBase
 from pygeodesy.interns import _Nv00_, _COMMASPACE_,  _pole_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _ALL_OTHER
@@ -48,7 +48,7 @@ from pygeodesy.units import Bearing, Distance, Height, Scalar
 # from math import fabs  # from .nvectorBase
 
 __all__ = _ALL_LAZY.ellipsoidalNvector
-__version__ = '24.06.08'
+__version__ = '24.06.15'
 
 
 class Ned(_Ned):
@@ -95,9 +95,9 @@ class Cartesian(CartesianEllipsoidalBase):
                                    override this L{LatLon} class or specify
                                    C{B{LatLon} is None}.
 
-           @return: The geodetic point (L{LatLon}) or if B{C{LatLon}} is set
-                    to C{None}, an L{Ecef9Tuple}C{(x, y, z, lat, lon, height,
-                    C, M, datum)} with C{C} and C{M} if available.
+           @return: The geodetic point (L{LatLon}) or if C{B{LatLon} is None},
+                    an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
+                    with C{C} and C{M} if available.
 
            @raise TypeError: Invalid B{C{LatLon_and_kwds}}.
         '''
@@ -112,8 +112,8 @@ class Cartesian(CartesianEllipsoidalBase):
                                     override this C{Nvector} class or specify
                                     C{B{Nvector} is None}.
 
-           @return: The C{n-vector} components (C{Nvector}) or if B{C{Nvector}}
-                    is set to C{None}, a L{Vector4Tuple}C{(x, y, z, h)}
+           @return: The C{n-vector} components (C{Nvector}) or if C{B{Nvector}
+                    is None}, a L{Vector4Tuple}C{(x, y, z, h)}.
 
            @raise TypeError: Invalid B{C{Nvector_and_kwds}}.
         '''
@@ -176,9 +176,9 @@ class LatLon(LatLonNvectorBase, LatLonEllipsoidalBase):
 
            @return: Delta from this to the other point (B{C{Ned}}).
 
-           @raise TypeError: The B{C{other}} point is not L{LatLon} or
-                             B{C{Ned}} is not L{pygeodesy.Ned} nor
-                             L{pygeodesy.Ned4Tuple} nor DEPRECATED L{Ned}.
+           @raise TypeError: The B{C{other}} point is not L{LatLon} or B{C{Ned}}
+                             is not an L{Ned4Tuple<pygeodesy.Ned4Tuple>} nor an
+                             L{Ned<pygeodesy.Ned>} nor a DEPRECATED L{Ned}.
 
            @raise ValueError: If ellipsoids are incompatible.
         '''
@@ -196,8 +196,8 @@ class LatLon(LatLonNvectorBase, LatLonEllipsoidalBase):
         N, kwds = _xkwds_pop2(Ned_and_kwds, Ned=Ned)
         if issubclassof(N, Ned4Tuple):
             ned_ += _MODS.ltp.Ltp(self, ecef=self.Ecef(self.datum)),
-        elif not issubclassof(N, _Ned):
-            raise _IsnotError(Fmt.sub_class(_Ned, Ned4Tuple), Ned=N)
+        else:
+            _xsubclassof(_Ned, Ned4Tuple, Ned=N)
         return N(*ned_, **_xkwds(kwds, name=self.name))
 
 #     def destination(self, distance, bearing, radius=R_M, height=None):
@@ -223,7 +223,7 @@ class LatLon(LatLonNvectorBase, LatLonEllipsoidalBase):
 #         y = gc.cross(v1).times(sin(r))  # component of v2 perpendicular to v1
 #
 #         v2 = x.plus(y).unit()
-#         return v2.toLatLon(height=self.height if height is C{None} else height)
+#         return v2.toLatLon(height=self._heigHt(height))
 
     def destinationNed(self, delta):
         '''Calculate the destination point using the supplied NED delta
@@ -234,8 +234,8 @@ class LatLon(LatLonNvectorBase, LatLonEllipsoidalBase):
 
            @return: Destination point (L{LatLon}).
 
-           @raise TypeError: If B{C{delta}} is not L{pygeodesy.Ned} or
-                             DEPRECATED L{Ned}.
+           @raise TypeError: If B{C{delta}} is not an L{Ned<pygeodesy.Ned>}
+                             or a DEPRECATED L{Ned}.
         '''
         _xinstanceof(_Ned, delta=delta)
 
@@ -391,9 +391,9 @@ class LatLon(LatLonNvectorBase, LatLonEllipsoidalBase):
                                       to override this L{Cartesian} class or specify
                                       C{B{Cartesian}=None}.
 
-           @return: The geodetic point (L{Cartesian}) or if B{C{Cartesian}} is set
-                    to C{None}, an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M,
-                    datum)} with C{C} and C{M} if available.
+           @return: The geodetic point (L{Cartesian}) or if C{B{Cartesian} is None},
+                    an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
+                    C{C} and C{M} if available.
 
            @raise TypeError: Invalid B{C{Cartesian}} or other B{C{Cartesian_and_kwds}}.
         '''
@@ -476,9 +476,9 @@ class Nvector(NvectorBase):
                                       to override this L{Cartesian} class or specify
                                       C{B{Cartesian} is None}.
 
-           @return: The cartesian point (L{Cartesian}) or if B{C{Cartesian}} is set
-                    to C{None}, an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M,
-                    datum)} with C{C} and C{M} if available.
+           @return: The cartesian point (L{Cartesian}) or if C{B{Cartesian} is None},
+                    an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
+                    C{C} and C{M} if available.
 
            @raise TypeError: Invalid B{C{Cartesian_and_kwds}}.
         '''
@@ -494,9 +494,9 @@ class Nvector(NvectorBase):
                                    to override this L{LatLon} class or specify
                                    C{B{LatLon} is None}.
 
-           @return: The geodetic point (L{LatLon}) or if B{C{LatLon}} is set
-                    to C{None}, an L{Ecef9Tuple}C{(x, y, z, lat, lon, height,
-                    C, M, datum)} with C{C} and C{M} if available.
+           @return: The geodetic point (L{LatLon}) or if C{B{LatLon} is None},
+                    an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
+                    with C{C} and C{M} if available.
 
            @raise TypeError: Invalid B{C{LatLon_and_kwds}}.
         '''
@@ -528,29 +528,23 @@ def meanOf(points, datum=_WGS84, height=None, wrap=False,
 
        @arg points: Points to be averaged (L{LatLon}[]).
        @kwarg datum: Optional datum to use (L{Datum}).
-       @kwarg height: Optional height at mean point, overriding
-                      the mean height (C{meter}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} B{C{points}}
-                    (C{bool}).
-       @kwarg LatLon_and_kwds: Optional B{C{LatLon}} class to return
-                     the mean points and overriding this L{LatLon}
-                     (or C{None}) and additional B{C{LatLon}}
-                     keyword arguments, ignored if C{B{LatLon}
-                     is None}.
-
-       @return: Geographic mean point and mean height (B{C{LatLon}})
-                or if B{C{LatLon}} is C{None}, an L{Ecef9Tuple}C{(x,
-                y, z, lat, lon, height, C, M, datum)} with C{C} and
-                C{M} if available.
+       @kwarg height: Optional height at mean point, overriding the mean
+                      height (C{meter}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} B{C{points}} (C{bool}).
+       @kwarg LatLon_and_kwds: Optional B{C{LatLon}} class to return the mean
+                     points (or C{None}) and additional B{C{LatLon}} keyword
+                     arguments, ignored if C{B{LatLon} is None}.
+
+       @return: Geographic mean point and height (B{C{LatLon}}) or if C{B{LatLon}
+                is None}, an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M,
+                datum)} with C{C} and C{M} if available.
 
        @raise ValueError: Insufficient number of B{C{points}}.
     '''
     Ps = _Nvll.PointsIter(points, wrap=wrap)
-    # geographic mean
-    m = sumOf(p._N_vector for p in Ps.iterate(closed=False))
-    kwds = _xkwds(LatLon_and_kwds, height=height, datum=datum,
-                                   LatLon=LatLon, name__=meanOf)
-    return m.toLatLon(**kwds)
+    n  =  sumOf(p._N_vector for p in Ps.iterate(closed=False))
+    return n.toLatLon(**_xkwds(LatLon_and_kwds, height=height, datum=datum,
+                                                LatLon=LatLon, name__=meanOf))
 
 
 def nearestOn(point, point1, point2, within=True, height=None, wrap=False,

pygeodesy/ellipsoidalVincenty.py

@@ -72,7 +72,7 @@ from pygeodesy.utily import atan2b, atan2d, sincos2, sincos2d, unroll180, wrap18
 from math import atan2, cos, degrees, fabs, radians, tan
 
 __all__ = _ALL_LAZY.ellipsoidalVincenty
-__version__ = '23.12.18'
+__version__ = '24.06.11'
 
 _antipodal_to_ = _SPACE_(_antipodal_, _to_)
 
@@ -102,7 +102,7 @@ class Cartesian(CartesianEllipsoidalBase):
                                    B{datum}=...} to override this L{LatLon}
                                    class or specify C{B{LatLon}=None}.
 
-           @return: The geodetic point (L{LatLon}) or if B{C{LatLon}} is C{None},
+           @return: The geodetic point (L{LatLon}) or if C{B{LatLon} is None},
                     an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
                     with C{C} and C{M} if available.
 
@@ -175,20 +175,18 @@ class LatLon(LatLonEllipsoidalBaseDI):
         self._iterations = Number_(limit, name=_limit_, low=4, high=1000) + 1
 
     def toCartesian(self, **Cartesian_datum_kwds):  # PYCHOK Cartesian=Cartesian, datum=None
-        '''Convert this point to C{Vincenty}-based cartesian (ECEF)
-           coordinates.
+        '''Convert this point to C{Vincenty}-based cartesian (ECEF) coordinates.
 
            @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}} and other
                             keyword arguments, ignored if C{B{Cartesian}=None}.  Use
                             C{B{Cartesian}=...} to override this L{Cartesian} class
                             or specify C{B{Cartesian}=None}.
 
-           @return: The cartesian point (L{Cartesian}) or if B{C{Cartesian}}
-                    is C{None}, an L{Ecef9Tuple}C{(x, y, z, lat, lon, height,
-                    C, M, datum)} with C{C} and C{M} if available.
+           @return: The cartesian point (L{Cartesian}) or if C{B{Cartesian} is None},
+                    an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
+                    C{C} and C{M} if available.
 
-           @raise TypeError: Invalid B{C{Cartesian}}, B{C{datum}} or other
-                             B{C{Cartesian_datum_kwds}}.
+           @raise TypeError: Invalid B{C{Cartesian}}, B{C{datum}} or other B{C{Cartesian_datum_kwds}}.
         '''
         kwds = _xkwds(Cartesian_datum_kwds, Cartesian=Cartesian,
                                                 datum=self.datum)
@@ -199,12 +197,11 @@ class LatLon(LatLonEllipsoidalBaseDI):
 
            @raise TypeError: The B{C{other}} point is not L{LatLon}.
 
-           @raise ValueError: If this and the B{C{other}} point's L{Datum}
-                              ellipsoids are not compatible.
+           @raise ValueError: If this and the B{C{other}} point's L{Datum} ellipsoids are
+                              not compatible.
 
-           @raise VincentyError: Vincenty fails to converge for the current
-                                 L{LatLon.epsilon} and L{LatLon.iterations}
-                                 limits.
+           @raise VincentyError: Vincenty fails to converge for the current limits, see
+                                 L{epsilon<LatLon.epsilon>} and L{iterations<LatLon.iterations>}.
         '''
         E = self.ellipsoid()
         f = E.f