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

pygeodesy/ellipsoidalBase.py

@@ -18,15 +18,13 @@ from pygeodesy.cartesianBase import CartesianBase  # PYCHOK used!
 from pygeodesy.datums import Datum, Datums, _earth_ellipsoid, _ellipsoidal_datum, \
                              Transform, _WGS84,  _EWGS84, _xinstanceof  # _spherical_datum
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
-from pygeodesy.errors import _incompatible, _IsnotError, RangeError, _TypeError, \
-                             _ValueError, _xattr, _xellipsoidal, _xError, _xkwds, \
-                             _xkwds_not
+from pygeodesy.errors import _IsnotError, RangeError, _TypeError, _xattr, _xellipsoidal, \
+                             _xellipsoids, _xError, _xkwds, _xkwds_not
 # from pygeodesy.fmath import favg  # _MODS
 from pygeodesy.interns import NN, _COMMA_, _ellipsoidal_
 from pygeodesy.latlonBase import LatLonBase, _trilaterate5,  fabs, _Wrap
-# from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS  # from .named
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.lcc import toLcc  # _MODS
-from pygeodesy.named import _name1__,  _ALL_DOCS, _ALL_LAZY, _MODS
 # from pygeodesy.namedTuples import Vector3Tuple  # _MODS
 from pygeodesy.props import deprecated_method, deprecated_property_RO, \
                             Property_RO, property_doc_, property_RO, _update_all
@@ -37,7 +35,7 @@ from pygeodesy.units import Epoch, _isDegrees, Radius_, _1mm as _TOL_M
 # from math import fabs  # from .latlonBase
 
 __all__ = _ALL_LAZY.ellipsoidalBase
-__version__ = '24.05.31'
+__version__ = '24.06.24'
 
 
 class CartesianEllipsoidalBase(CartesianBase):
@@ -121,13 +119,13 @@ class CartesianEllipsoidalBase(CartesianBase):
            @kwarg Vector_kwds: Optional, additional B{C{Vector}} keyword arguments,
                                ignored if C{B{Vector} is None}.
 
-           @return: If B{C{sphere}} is C{True}, a 2-tuple of the C{center} and C{radius}
-                    of the intersection of the I{spheres}.  The C{radius} is C{0.0} for
+           @return: If C{B{sphere} is True}, a 2-tuple of the C{center} and C{radius} of
+                    the intersection of the I{spheres}.  The C{radius} is C{0.0} for
                     abutting spheres (and the C{center} is aka the I{radical center}).
 
-                    If B{C{sphere}} is C{False}, a 2-tuple with the two intersection
-                    points of the I{circles}.  For abutting circles, both points are
-                    the same instance, aka the I{radical center}.
+                    If C{B{sphere} is False}, a 2-tuple with the two intersection points
+                    of the I{circles}.  For abutting circles, both points are the same
+                    instance, aka the I{radical center}.
 
            @raise IntersectionError: Concentric, invalid or non-intersecting spheres or circles.
 
@@ -225,26 +223,25 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @arg latlonh: Latitude (C{degrees} or DMS C{str} with N or S suffix) or
                          a previous C{LatLon} instance provided C{B{lon}=None}.
-           @kwarg lon: Longitude (C{degrees} or DMS C{str} with E or W suffix) or
-                       C(None), indicating B{C{latlonh}} is a C{LatLon}.
-           @kwarg height: Optional height above (or below) the earth surface
-                          (C{meter}, same units as the datum's ellipsoid axes).
+           @kwarg lon: Longitude (C{degrees} or DMS C{str} with E or W suffix) or C(None),
+                       indicating B{C{latlonh}} is a C{LatLon}.
+           @kwarg height: Optional height above (or below) the earth surface (C{meter},
+                          same units as the datum's ellipsoid axes).
            @kwarg datum: Optional, ellipsoidal datum to use (L{Datum}, L{Ellipsoid},
                          L{Ellipsoid2} or L{a_f2Tuple}).
            @kwarg reframe: Optional reference frame (L{RefFrame}).
-           @kwarg epoch: Optional epoch to observe for B{C{reframe}} (C{scalar}),
-                         a non-zero, fractional calendar year; silently ignored
-                         if C{B{reframe}=None}.
-           @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}}
-                        (C{bool}).
+           @kwarg epoch: Optional epoch to observe for B{C{reframe}} (C{scalar}), a
+                         non-zero, fractional calendar year, but silently ignored if
+                         C{B{reframe}=None}.
+           @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}} (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-           @raise RangeError: Value of C{lat} or B{C{lon}} outside the valid
-                              range and L{rangerrors} set to C{True}.
+           @raise RangeError: Value of C{lat} or B{C{lon}} outside the valid range and
+                              L{rangerrors} set to C{True}.
 
-           @raise TypeError: If B{C{latlonh}} is not a C{LatLon}, B{C{datum}} is
-                             not a L{Datum}, B{C{reframe}} is not a L{RefFrame}
-                             or B{C{epoch}} is not C{scalar} non-zero.
+           @raise TypeError: If B{C{latlonh}} is not a C{LatLon}, B{C{datum}} is not a
+                             L{Datum}, B{C{reframe}} is not a L{RefFrame} or B{C{epoch}}
+                             is not C{scalar} non-zero.
 
            @raise UnitError: Invalid B{C{lat}}, B{C{lon}} or B{C{height}}.
         '''
@@ -291,13 +288,6 @@ class LatLonEllipsoidalBase(LatLonBase):
         '''DEPRECATED, use method L{toRefFrame}.'''
         return self.toRefFrame(reframe2)
 
-    @Property_RO
-    def _css(self):
-        '''(INTERNAL) Get this C{LatLon} point as a Cassini-Soldner location (L{Css}).
-        '''
-        css = _MODS.css
-        return css.toCss(self, height=self.height, Css=css.Css, name=self.name)
-
     @property_doc_(''' this points's datum (L{Datum}).''')
     def datum(self):
         '''Get this point's datum (L{Datum}).
@@ -308,8 +298,7 @@ class LatLonEllipsoidalBase(LatLonBase):
     def datum(self, datum):
         '''Set this point's datum I{without conversion} (L{Datum}).
 
-           @raise TypeError: The B{C{datum}} is not a L{Datum}
-                             or not ellipsoidal.
+           @raise TypeError: The B{C{datum}} is not a L{Datum} or not ellipsoidal.
         '''
         _xinstanceof(Datum, datum=datum)
         if not datum.isEllipsoidal:
@@ -418,9 +407,7 @@ class LatLonEllipsoidalBase(LatLonBase):
                 e = other.datum.ellipsoid
             except AttributeError:
                 e = E  # no datum, XXX assume equivalent?
-        if e != E:
-            raise _ValueError(e.named2, txt=_incompatible(E.named2))
-        return E
+        return _xellipsoids(E, e)
 
     @property_doc_(''' this point's observed or C{reframe} epoch (C{float}).''')
     def epoch(self):
@@ -644,13 +631,6 @@ class LatLonEllipsoidalBase(LatLonBase):
         '''
         return self._iteration
 
-    @Property_RO
-    def _lcc(self):
-        '''(INTERNAL) Get this C{LatLon} point as a Lambert location (L{Lcc}).
-        '''
-        lcc = _MODS.lcc
-        return lcc.toLcc(self, height=self.height, Lcc=lcc.Lcc, name=self.name)
-
     def midpointTo(self, other, height=None, fraction=_0_5, wrap=False):
         '''Find the midpoint on a geodesic between this and an other point.
 
@@ -722,20 +702,6 @@ class LatLonEllipsoidalBase(LatLonBase):
                                          height=height, wrap=wrap, tol=tol)
         return t.closest
 
-    @Property_RO
-    def _osgr(self):
-        '''(INTERNAL) Get this C{LatLon} point as an OSGR coordinate (L{Osgr}),
-           based on the OS recommendation.
-        '''
-        return _MODS.osgr.toOsgr(self, kTM=False, name=self.name)  # datum=self.datum
-
-    @Property_RO
-    def _osgrTM(self):
-        '''(INTERNAL) Get this C{LatLon} point as an OSGR coordinate (L{Osgr})
-           based on I{Karney}'s Krüger implementation.
-        '''
-        return _MODS.osgr.toOsgr(self, kTM=True, name=self.name)  # datum=self.datum
-
     def parse(self, strllh, height=0, datum=None, epoch=None, reframe=None,
                                         sep=_COMMA_, wrap=False, **name):
         '''Parse a string consisting of C{"lat, lon[, height]"},
@@ -832,8 +798,7 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @see: Function L{pygeodesy.toCss}.
         '''
-        return self._css if not toCss_kwds else _MODS.css.toCss(
-               self, **_name1__(toCss_kwds, _or_nameof=self))
+        return _MODS.css.toCss(self, **self._name1__(toCss_kwds))
 
     def toDatum(self, datum2, height=None, **name):
         '''Convert this point to an other datum.
@@ -869,8 +834,7 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @see: Function L{pygeodesy.toEtm8}.
         '''
-        return self._etm if not toEtm8_kwds else _MODS.etm.toEtm8(
-               self, **_name1__(toEtm8_kwds, _or_nameof=self))
+        return _MODS.etm.toEtm8(self, **self._name1__(toEtm8_kwds)) if toEtm8_kwds else self._etm
 
     def toLcc(self, **toLcc_kwds):
         '''Convert this C{LatLon} point to a Lambert location.
@@ -881,8 +845,7 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @see: Function L{pygeodesy.toLcc}.
         '''
-        return self._lcc if not toLcc_kwds else _MODS.lcc.toLcc(
-               self, **_name1__(toLcc_kwds, _or_nameof=self))
+        return _MODS.lcc.toLcc(self, **self._name1__(toLcc_kwds))
 
     def toMgrs(self, center=False, pole=NN):
         '''Convert this C{LatLon} point to an MGRS coordinate.
@@ -911,12 +874,7 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @see: Function L{pygeodesy.toOsgr}.
         '''
-        if toOsgr_kwds:
-            kwds = _name1__(toOsgr_kwds, _or_nameof=self)
-            r = _MODS.osgr.toOsgr(self, kTM=kTM, **kwds)
-        else:
-            r =  self._osgrTM if kTM else self._osgr
-        return r
+        return _MODS.osgr.toOsgr(self, kTM=kTM, **self._name1__(toOsgr_kwds))
 
     def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, height=None, **name):
         '''Convert this point to an other reference frame and epoch.

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}.