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

pygeodesy/geodesicx/gxarea.py

@@ -17,7 +17,7 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 # make sure int/int division yields float quotient
 from __future__ import division as _; del _  # noqa: E702 ;
 
-from pygeodesy.basics import isodd, unsigned0
+from pygeodesy.basics import _copysign, isodd, unsigned0
 from pygeodesy.constants import NAN, _0_0, _0_5, _720_0
 from pygeodesy.internals import printf, typename
 # from pygeodesy.interns import _COMMASPACE_  # from .lazily
@@ -31,19 +31,16 @@ from pygeodesy.props import Property, Property_RO, property_RO
 from math import fmod as _fmod
 
 __all__ = ()
-__version__ = '25.05.12'
+__version__ = '25.06.04'
 
 
 class GeodesicAreaExact(_NamedBase):
-    '''Area and perimeter of a geodesic polygon, an enhanced
-       version of I{Karney}'s Python class U{PolygonArea
-       <https://GeographicLib.SourceForge.io/html/python/
-       code.html#module-geographiclib.polygonarea>} using
-       the more accurate surface area.
-
-       @note: The name of this class C{*Exact} is a misnomer, see
-              I{Karney}'s comments at C++ attribute U{GeodesicExact._c2
-              <https://GeographicLib.SourceForge.io/C++/doc/
+    '''Area and perimeter of a geodesic polygon, an enhanced version of I{Karney}'s
+       Python class U{PolygonArea<https://GeographicLib.SourceForge.io/html/python/
+       code.html#module-geographiclib.polygonarea>} using the more accurate surface area.
+
+       @note: The name of this class C{*Exact} is a misnomer, see I{Karney}'s comments at
+              C++ attribute U{GeodesicExact._c2<https://GeographicLib.SourceForge.io/C++/doc/
               GeodesicExact_8cpp_source.html>}.
     '''
     _Area    =  None
@@ -140,46 +137,45 @@ class GeodesicAreaExact(_NamedBase):
 
     @Property_RO
     def area0x(self):
-        '''Get the ellipsoid's surface area (C{meter} I{squared}),
-           more accurate for very I{oblate} ellipsoids.
+        '''Get the ellipsoid's surface area (C{meter} I{squared}), more accurate
+           for very I{oblate} ellipsoids.
         '''
         return self.ellipsoid.areax  # not .area!
 
     area0 = area0x  # for C{geographiclib} compatibility
 
-    def Compute(self, reverse=False, sign=True):
+    def Compute(self, reverse=False, sign=True, polar=False):
         '''Compute the accumulated perimeter and area.
 
-           @kwarg reverse: If C{True}, clockwise traversal counts as a
-                           positive area instead of counter-clockwise
-                           (C{bool}).
-           @kwarg sign: If C{True}, return a signed result for the area if
-                        the polygon is traversed in the "wrong" direction
-                        instead of returning the area for the rest of the
-                        earth.
-
-           @return: L{Area3Tuple}C{(number, perimeter, area)} with the
-                    number of points, the perimeter in C{meter} and the
-                    area in C{meter**2}.  The perimeter includes the
-                    length of a final edge, connecting the current to
-                    the initial point, if this polygon was initialized
-                    with C{polyline=False}.  For perimeter only, i.e.
-                    C{polyline=True}, area is C{NAN}.
-
-           @note: Arbitrarily complex polygons are allowed.  In the case
-                  of self-intersecting polygons, the area is accumulated
-                  "algebraically".  E.g., the areas of the 2 loops in a
-                  I{figure-8} polygon will partially cancel.
+           @kwarg reverse: If C{True}, clockwise traversal counts as a positive area instead
+                           of counter-clockwise (C{bool}).
+           @kwarg sign: If C{True}, return a signed result for the area if the polygon is
+                        traversed in the "wrong" direction instead of returning the area for
+                        the rest of the earth.
+           @kwarg polar: Use C{B{polar}=True} if the polygon encloses a pole (C{bool}), see
+                         function L{ispolar<pygeodesy.points.ispolar>} and U{area of a polygon
+                         enclosing a pole<https://GeographicLib.SourceForge.io/C++/doc/
+                         classGeographicLib_1_1GeodesicExact.html#a3d7a9155e838a09a48dc14d0c3fac525>}.
+
+           @return: L{Area3Tuple}C{(number, perimeter, area)} with the number of points, the
+                    perimeter in C{meter} and the (signed) area in C{meter**2}.  The perimeter
+                    includes the length of a final edge, connecting the current to the initial
+                    point, if this polygon was initialized with C{polyline=False}.  For perimeter
+                    only, i.e. C{polyline=True}, area is C{NAN}.
+
+           @note: Arbitrarily complex polygons are allowed.  In the case of self-intersecting
+                  polygons, the area is accumulated "algebraically".  E.g., the areas of both
+                  loops in a I{figure-8} polygon will partially cancel.
 
            @note: More points and edges can be added after this call.
         '''
         r, n = None, self.num
         if n < 2:
             p = _0_0
-            a = NAN if self.polyline else p
+            a =  NAN if n > 0 and self.polyline else p
         elif self._Area:
             r = self._Inverse(self.lat1, self.lon1, self.lat0, self.lon0)
-            a = self._reduced(r.S12, reverse, sign, r.xing)
+            a = self._reduced(r.S12, r.xing, n, reverse=reverse, sign=sign, polar=polar)
             p = self._Peri.Sum(r.s12)
         else:
             p = self._Peri.Sum()
@@ -279,7 +275,7 @@ class GeodesicAreaExact(_NamedBase):
         t = _COMMASPACE_.join(pairs(d, prec=10))
         printf('%s %s: %s (%s)', self.named2, n, t, callername(up=2))
 
-    def _reduced(self, S12, reverse, sign, xing):
+    def _reduced(self, S12, xing, n, reverse=False, sign=True, polar=False):
         '''(INTERNAL) Accumulate and reduce area to allowed range.
         '''
         a0 =  self.area0x
@@ -296,6 +292,8 @@ class GeodesicAreaExact(_NamedBase):
             a = A.Add(-a0)
         elif a <= -a0_:
             a = A.Add( a0)
+        if polar:  # see .geodesicw._gwrapped.Geodesic.Area
+            a = A.Add(_copysign(a0 * _0_5 * n, a))  # - if reverse or sign?
         return unsigned0(a)
 
     def Reset(self):
@@ -313,63 +311,53 @@ class GeodesicAreaExact(_NamedBase):
 
     Clear = Reset
 
-    def TestEdge(self, azi, s, reverse=False, sign=True):
+    def TestEdge(self, azi, s, **reverse_sign_polar):
         '''Compute the properties for a tentative, additional edge
 
            @arg azi: Azimuth at the current the point (compass C{degrees}).
            @arg s: Length of the edge (C{meter}).
-           @kwarg reverse: If C{True}, clockwise traversal counts as a
-                           positive area instead of counter-clockwise
-                           (C{bool}).
-           @kwarg sign: If C{True}, return a signed result for the area if
-                        the polygon is traversed in the "wrong" direction
-                        instead of returning the area for the rest of the
-                        earth.
-
-           @return: L{Area3Tuple}C{(number, perimeter, area)}.
+           @kwarg reverse_sign_polar: Optional C{B{reverse}=False}, C{B{sign}=True} and
+                          C{B{polar}=False} keyword arguments, see method L{Compute}.
 
-           @raise GeodesicError: No points.
+           @return: L{Area3Tuple}C{(number, perimeter, area)}, with C{perimeter} and
+                    C{area} both C{NAN} for insuffcient C{number} of points.
         '''
-        n = self.num + 1
-        p = self._Peri.Sum(s)
-        if self.polyline:
-            a, r = NAN, None
-        elif n < 2:
-            raise GeodesicError(num=self.num)
+        r, n = None, self.num + 1
+        if n < 2:  # raise GeodesicError(num=self.num)
+            a = p = NAN  # like .test_Planimeter19
         else:
-            d  = self._Direct(azi, s)
-            r  = self._Inverse(d.lat2, d.lon2, self.lat0, self.lon0)
-            a  = self._reduced(d.S12 + r.S12, reverse, sign, d.xing + r.xing)
-            p += r.s12
+            p = self._Peri.Sum(s)
+            if self.polyline:
+                a  = NAN
+            else:
+                d  = self._Direct(azi, s)
+                r  = self._Inverse(d.lat2, d.lon2, self.lat0, self.lon0)
+                a  = self._reduced(d.S12 + r.S12, d.xing + r.xing, n, **reverse_sign_polar)
+                p += r.s12
         if self.verbose:  # PYCHOK no cover
             self._print(n, p, a, r, azi=azi, s=s)
         return Area3Tuple(n, p, a)
 
-    def TestPoint(self, lat, lon, reverse=False, sign=True):
+    def TestPoint(self, lat, lon, **reverse_sign_polar):
         '''Compute the properties for a tentative, additional vertex
 
            @arg lat: Latitude of the point (C{degrees}).
            @arg lon: Longitude of the point (C{degrees}).
-           @kwarg reverse: If C{True}, clockwise traversal counts as a
-                           positive area instead of counter-clockwise
-                           (C{bool}).
-           @kwarg sign: If C{True}, return a signed result for the area if
-                        the polygon is traversed in the "wrong" direction
-                        instead of returning the area for the rest of the
-                        earth.
+           @kwarg reverse_sign_polar: Optional C{B{reverse}=False}, C{B{sign}=True} and
+                          C{B{polar}=False} keyword arguments, see method L{Compute}.
 
            @return: L{Area3Tuple}C{(number, perimeter, area)}.
         '''
         r, n = None, self.num + 1
         if n < 2:
             p = _0_0
-            a = NAN if self.polyline else p
+            a =  NAN if self.polyline else p
         else:
             i = self._Inverse(self.lat1, self.lon1, lat, lon)
             p = self._Peri.Sum(i.s12)
             if self._Area:
                 r  = self._Inverse(lat, lon, self.lat0, self.lon0)
-                a  = self._reduced(i.S12 + r.S12, reverse, sign, i.xing + r.xing)
+                a  = self._reduced(i.S12 + r.S12, i.xing + r.xing, n, **reverse_sign_polar)
                 p += r.s12
             else:
                 a = NAN

pygeodesy/geodesicx/gxbases.py

@@ -9,7 +9,7 @@ U{GeographicLib<https://GeographicLib.SourceForge.io>} documentation.
 '''
 
 from pygeodesy.basics import isodd,  _MODS
-from pygeodesy.constants import _EPSmin as _TINY, _0_0
+from pygeodesy.constants import _EPSmin as _TINY, _0_0, isfinite
 from pygeodesy.errors import _or, _xkwds_item2
 from pygeodesy.fmath import hypot as _hypot
 # from pygeodesy.interns import _numpy_  # _MODS
@@ -20,7 +20,7 @@ from pygeodesy.karney import _CapsBase, GeodesicError, _2cos2x, \
 from math import fabs, ldexp as _ldexp
 
 __all__ = ()
-__version__ = '24.09.07'
+__version__ = '25.06.01'
 
 # valid C{nC4}s and C{C4order}s, see _xnC4 below
 _nC4s = {24: 2900, 27: 4032, 30: 5425}
@@ -147,12 +147,23 @@ def _sinf1cos2d(lat, f1):
     return sbet, (cbet if fabs(cbet) > _TINY else _TINY)
 
 
+def _toNAN(outmask, *args):
+    '''(INTERNAL) Is any C{arg} not finite?
+    '''
+    if (outmask & _CapsBase.NONFINITONAN):  # Caps.NONFINITONAN
+        for arg in args:
+            if not isfinite(arg):
+                return True
+    return False
+
+
 def _xnC4(**name_nC4):
     '''(INTERNAL) Validate C{C4order}.
     '''
     n, nC4 = _xkwds_item2(name_nC4)
     if nC4 not in _nC4s or not isinstance(nC4, int):
-        raise GeodesicError(n, nC4, txt_not_=_or(*map(str, _nC4s)))
+        t = map(str, _nC4s)
+        raise GeodesicError(n, nC4, txt_not_=_or(*t))
     return _nC4s[nC4]
 
 

pygeodesy/geodesicx/gxline.py

@@ -37,13 +37,14 @@ from __future__ import division as _; del _  # noqa: E702 ;
 # - s and c prefixes mean sin and cos
 
 # from pygeodesy.basics import _xinstanceof  # _MODS
-from pygeodesy.constants import NAN, _EPSqrt as _TOL, _0_0, _1_0, \
-                               _180_0, _2__PI, _copysign_1_0, isfinite
+from pygeodesy.constants import NAN, _EPSqrt as _TOL, \
+                               _0_0, _1_0, _180_0, _2__PI, \
+                               _copysign_1_0, isfinite
 from pygeodesy.errors import _xError, _xkwds_pop2
 from pygeodesy.fsums import fsumf_, fsum1f_
 from pygeodesy.geodesicx.gxbases import _cosSeries, _GeodesicBase, \
                                         _sincos12, _sin1cos2, \
-                                        _sinf1cos2d, _TINY
+                                        _sinf1cos2d, _TINY, _toNAN
 # from pygeodesy.geodesicw import _Intersecant2  # _MODS
 from pygeodesy.lazily import _ALL_DOCS, _ALL_MODS as _MODS
 from pygeodesy.karney import _around, _atan2d, Caps, GDict, _fix90, \
@@ -55,7 +56,7 @@ from pygeodesy.utily import atan2, atan2d as _atan2d_reverse, sincos2
 from math import cos, degrees, fabs, floor, radians, sin
 
 __all__ = ()
-__version__ = '25.05.12'
+__version__ = '25.05.28'
 
 _glXs = []  # instances of C{[_]GeodesicLineExact} to be updated
 
@@ -91,6 +92,7 @@ class _GeodesicLineExact(_GeodesicBase):
 #   _salp1 = _calp1 = NAN
 #   _somg1 = _comg1 = NAN
 #   _ssig1 = _csig1 = NAN
+#   _toNAN =  False
 
     def __init__(self, gX, lat1, lon1, azi1, caps, **name_):
         '''(INTERNAL) New C{[_]GeodesicLineExact} instance.
@@ -104,6 +106,7 @@ class _GeodesicLineExact(_GeodesicBase):
             salp1, calp1 = _sincos2d(_around(azi1))
         if name_:
             self.name = name_
+        self._toNAN = _toNAN(caps, lat1, lon1, azi1, salp1, calp1)
 
         self._gX    = gX  # GeodesicExact only
         self._lat1  = lat1 = _fix90(lat1)
@@ -297,9 +300,9 @@ class _GeodesicLineExact(_GeodesicBase):
         gX = self.geodesic  # ._gX
         r  = GDict(a12=NAN, s12=NAN)  # both a12 and s12, always
 
-        if not isfinite(s12_a12):
+        if self._toNAN or not isfinite(s12_a12):  # _toNAN(outmask, s12_a12)?
             # E2 = sig12 = ssig12 = csig12 = NAN
-            return r._toNAN(outmask)
+            return r._toNAN(outmask | Cs.NONFINITONAN)  # for backward compatibility
         elif arcmode:  # s12_a12 is (spherical) arc length
             r.set_(a12=s12_a12)
             sig12 = radians(s12_a12)

pygeodesy/geoids.py

@@ -355,7 +355,7 @@ class _GeoidBase(_HeightBase):
         # build grid axis, hi = lo + (n - 1) * d
         m, a = len2(frange(lo, n, d))
         if m != n:
-            raise LenError(self.__class__, grid=m, **{name: n})
+            raise LenError(type(self), grid=m, **{name: n})
         if d < 0:
             d, a = -d, list(reversed(a))
         a = self.numpy.array(a)

pygeodesy/hausdorff.py

@@ -85,7 +85,7 @@ from pygeodesy import unitsBase as _unitsBase  # _Str_..., _xUnit, _xUnits
 from random import Random
 
 __all__ = _ALL_LAZY.hausdorff
-__version__ = '25.05.21'
+__version__ = '25.05.26'
 
 _formy = _MODS.into(formy=__name__)
 
@@ -124,7 +124,7 @@ class Hausdorff(_Named):
            @raise HausdorffError: Insufficient number of B{C{point1s}} or an invalid
                                   B{C{point1}}, B{C{seed}} or B{C{units}}.
         '''
-        name, kwds = _name2__(**name__kwds)  # name__=self.__class__
+        name, kwds = _name2__(**name__kwds)  # name__=type(self)
         if name:
             self.name = name
 

pygeodesy/heights.py

@@ -92,7 +92,7 @@ from pygeodesy.units import _isDegrees, Float_, Int_
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.heights
-__version__ = '25.05.12'
+__version__ = '25.05.26'
 
 _error_  = 'error'
 _formy   = _MODS.into(formy=__name__)
@@ -212,7 +212,7 @@ class _HeightNamed(_Named):  # in .geoids
             n, lats = len2(lats)
             m, lons = len2(lons)
             if n != m:  # format a LenError, but raise self._Error
-                e = LenError(self.__class__, lats=n, lons=m, txt=None)
+                e = LenError(type(self), lats=n, lons=m, txt=None)
                 raise self._Error(str(e))
             llis = [LLiC(*t, datum=d) for t in zip(lats, lons)]
         return llis
@@ -363,13 +363,13 @@ class _HeightBase(_HeightNamed):  # in .geoids
     def numpy(self):
         '''Get the C{numpy} module or C{None}.
         '''
-        return _xnumpy(self.__class__, 1, 9)  # overwrite property_ROver
+        return _xnumpy(type(self), 1, 9)  # overwrite property_ROver
 
     @property_ROver
     def scipy(self):
         '''Get the C{scipy} module or C{None}.
         '''
-        return _xscipy(self.__class__, 1, 2)  # overwrite property_ROver
+        return _xscipy(type(self), 1, 2)  # overwrite property_ROver
 
     @property_ROver
     def scipy_interpolate(self):

pygeodesy/internals.py

@@ -132,7 +132,7 @@ class _MODS_Base(object):
     def name(self):
         '''Get this name (C{str}).
         '''
-        return typename(self.__class__)
+        return typename(type(self))
 
     @_Property_RO
     def nix2(self):  # PYCHOK no cover
@@ -686,7 +686,7 @@ def _versions(sep=_SPACE_):
 
 
 __all__ = tuple(map(typename, (machine, print_, printf, typename)))
-__version__ = '25.04.14'
+__version__ = '25.05.26'
 
 if __name__ == _DMAIN_:
 

pygeodesy/interns.py

@@ -443,15 +443,15 @@ _LR_PAIRS  = {_LANGLE_:  _RANGLE_,
 
 __all__ = (_NN_,  # NOT MISSING!
             Str_.__name__)  # classes
-__version__ = '25.04.12'
+__version__ = '25.05.26'
 
 if __name__ == _DMAIN_:
 
-    def _main():
+    def _main(globalocals):
         from pygeodesy import itemsorted, printf
 
         t = b = 0
-        for n, v in itemsorted(locals(), asorted=False, reverse=True):
+        for n, v in itemsorted(globalocals, asorted=False, reverse=True):
             if n.endswith(_UNDER_) and n.startswith(_UNDER_) and \
                                    not n.startswith(_DUNDER_):
                 t += 1
@@ -459,10 +459,10 @@ if __name__ == _DMAIN_:
                 m  = n[1:-1]
                 if m != v and m.replace(_UNDER_, _SPACE_) != v:
                     printf('%4d: %s = %r', t, n, v)
-        n = len(locals())
+        n = len(globalocals)
         printf('%4d (%d) names, %s chars total, %.2f chars avg', t, n, b, float(b) / t, nl=1)
 
-    _main()
+    _main(globals())  # or locals()
 
 # **) MIT License
 #

pygeodesy/karney.py

@@ -166,7 +166,7 @@ from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '25.05.12'
+__version__ = '25.05.28'
 
 _2_4_       = '2.4'
 _K_2_0      = _getenv(_PYGEODESY_ENV(typename(_xgeographiclib)[2:]), _2_)
@@ -240,6 +240,8 @@ class Caps(object):
 
        C{LONG_UNROLL} - unroll C{lon2} in method C{.Direct},
 
+       C{NONFINITONAN} - set all C{GDict} items to C{NAN} iff any argument is C{non-finite}.
+
        C{REDUCEDLENGTH} - compute the reduced length C{m12},
 
        C{REVERSE2} - reverse azimuth C{azi2} by 180 degrees,
@@ -274,7 +276,7 @@ class Caps(object):
 
     LINE_CAPS     =  STANDARD_LINE | REDUCEDLENGTH | GEODESICSCALE  # .geodesici only
     LONG_UNROLL   =  1 << 15  # unroll C{lon2} in .Direct and .Position
-#                 =  1 << 16  # unused
+    NONFINITONAN  =  1 << 16  # see method GDict._toNAN
     LINE_OFF      =  1 << 17  # Line without updates from parent geodesic or rhumb
     REVERSE2      =  1 << 18  # reverse C{azi2}
     ALL           =  0x7F80 | _CAP_ALL  # without LONG_UNROLL, LINE_OFF, REVERSE2 and _DEBUG_*
@@ -327,9 +329,12 @@ if _FOR_DOCS:  # PYCHOK force ...
 else:
     Caps = Caps()  # PYCHOK singleton
 
-_key2Caps = dict(a12 =Caps.DISTANCE,  # in GDict._unCaps
+_key2Caps = dict(a12 =Caps.DISTANCE,  # in GDict._toNAN, -._unCaps
+                 azi1=Caps.AZIMUTH,
                  azi2=Caps.AZIMUTH,
+                 lat1=Caps.LATITUDE,
                  lat2=Caps.LATITUDE,
+                 lon1=Caps.LONGITUDE,
                  lon2=Caps.LONGITUDE,
                  m12 =Caps.REDUCEDLENGTH,
                  M12 =Caps.GEODESICSCALE,
@@ -353,6 +358,7 @@ class _CapsBase(_NamedBase):  # in .auxilats, .geodesicx.gxbases
     LINE_OFF      = Caps.LINE_OFF
     LONGITUDE     = Caps.LONGITUDE
     LONG_UNROLL   = Caps.LONG_UNROLL
+    NONFINITONAN  = Caps.NONFINITONAN
     REDUCEDLENGTH = Caps.REDUCEDLENGTH
     STANDARD      = Caps.STANDARD
     STANDARD_LINE = Caps.STANDARD_LINE  # for geodesici
@@ -449,11 +455,14 @@ class GDict(ADict):  # XXX _NamedDict
         '''
         return self._toTuple(Inverse10Tuple, dflt)
 
-    def _toNAN(self, outmask):  # .GeodesicLineExact._GenPosition
+    def _toNAN(self, outmask):  # .GeodesicExact._GDistInverse, .GeodesicLineExact._GenPosition
         '''(INTERNAL) Convert this C{GDict} to all C{NAN}s.
         '''
-        d = dict((n, NAN) for n in GeodSolve12Tuple._Names_)
-        return self.set_(**d)._unCaps(outmask)
+        if (outmask & Caps.NONFINITONAN):
+            d = dict((k, NAN) for k, C in _key2Caps.items()
+                                       if (outmask & C) == C)
+            self.set_(**d)
+        return self
 
     @deprecated_method
     def toRhumb7Tuple(self, dflt=NAN):  # PYCHOK no cover
@@ -543,7 +552,7 @@ class Inverse10Tuple(_GTuple):
                                    **updates)  # PYCHOK indent
 
 
-class _kWrapped(object):  # in .geodesicw
+class _kWrapped(_CapsBase):  # in .geodesicw
     '''(INTERNAL) Wrapper for some of I{Karney}'s U{geographiclib
         <https://PyPI.org/project/geographiclib>} classes.
     '''
@@ -554,13 +563,15 @@ class _kWrapped(object):  # in .geodesicw
            <https://PyPI.org/project/geographiclib>} package is installed,
            otherwise raise a C{LazyImportError}.
         '''
-        g = _xgeographiclib(type(self).__module__, 1, 49)
+        g = _xgeographiclib(type(self), 1, 49)
         from geographiclib.geodesic import Geodesic
         g.Geodesic = Geodesic
         from geographiclib.geodesicline import GeodesicLine
         g.GeodesicLine = GeodesicLine
         from geographiclib.geomath import Math
         g.Math = Math
+#       from geographiclib.polygonarea import PolygonArea
+#       g.PolygonArea = PolygonArea  # see below
         return g
 
     @property_ROnce
@@ -586,6 +597,11 @@ class _kWrapped(object):  # in .geodesicw
         return (_2_4_ if _K_2_4 else
                (_2_   if _K_2_0 else _1_)) if self.Math else NN
 
+    @property_ROnce
+    def _PolygonArea(self):  # lazy import
+        from geographiclib.polygonarea import PolygonArea
+        return PolygonArea
+
 _wrapped = _kWrapped()  # PYCHOK singleton, .datum, .test/base.py
 
 
@@ -830,7 +846,7 @@ def _norm180(deg):  # mimick geomath.Math.AngNormalize
         return d
 
 
-def _polygon(geodesic, points, closed, line, wrap):
+def _polygon(geodesic, points, closed, line, wrap, polar):
     '''(INTERNAL) Compute the area or perimeter of a polygon,
         using a L{GeodesicExact}, L{GeodesicSolve} or (if the
         C{geographiclib} package is installed) a C{Geodesic}
@@ -848,7 +864,7 @@ def _polygon(geodesic, points, closed, line, wrap):
         if not closed:  # closed only
             raise _ValueError(closed=closed, points=_composite_)
 
-        return points._sum1(_a_p, closed, line, wrap)
+        return points._sum1(_a_p, closed, line, wrap, polar)
 
     gP = geodesic.Polygon(line)
     _A = gP.AddPoint
@@ -867,7 +883,7 @@ def _polygon(geodesic, points, closed, line, wrap):
         _A(p0.lat, p0.lon)
 
     # gP.Compute returns (number_of_points, perimeter, signed area)
-    return gP.Compute(False, True)[1 if line else 2]
+    return gP.Compute(reverse=False, sign=True, polar=polar)[1 if line else 2]
 
 
 try:

pygeodesy/lcc.py

@@ -50,7 +50,7 @@ from pygeodesy.utily import atan1, degrees90, degrees180, sincos2, tanPI_2_2
 from math import atan, fabs, log, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.lcc
-__version__ = '25.05.12'
+__version__ = '25.05.26'
 
 _E0_   = 'E0'
 _N0_   = 'N0'
@@ -457,7 +457,7 @@ class Lcc(_NamedBase):
 #                                  h=self.height, conic=self.conic,
 #                                  name=self._name__(name))
 #       args, kwds = _args_kwds(**kwds)
-#       return self.__class__(*args, **kwds)  # .classof
+#       return type(self)(*args, **kwds)  # .classof
 
     @Property_RO
     def easting(self):

pygeodesy/props.py

@@ -26,7 +26,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, \
 from functools import wraps as _wraps
 
 __all__ = _ALL_LAZY.props
-__version__ = '25.05.21'
+__version__ = '25.05.26'
 
 _class_       = 'class'
 _DNL_         = _NL_ * 2  # PYCHOK used!
@@ -347,7 +347,7 @@ class property_RO(_PropertyBase):
             if Clas:  # overrides inst.__class__
                 d = Clas[0].__dict__.get(uname, MISSING)
             else:
-                d = getattr(inst.__class__, uname, MISSING)
+                d = getattr(type(inst), uname, MISSING)
 #               if d is MISSING:  # XXX superfluous
 #                   for c in type(inst).__mro__[:-1]:
 #                       if uname in c.__dict__:
@@ -403,7 +403,7 @@ class property_ROver(_property_RO___):
         '''
         v = self.method(inst)
         n = self.name
-        C = inst.__class__
+        C = type(inst)
         for c in C.__mro__:  # [:-1]
             if getattr(c, n, None) is self:
                 setattr(c, n, v)  # overwrite property_ROver

pygeodesy/sphericalBase.py

@@ -40,7 +40,7 @@ from pygeodesy.utily import acos1, asin1, atan2b, atan2d, degrees90, \
 from math import cos, fabs, log, sin, sqrt
 
 __all__ = _ALL_LAZY.sphericalBase
-__version__ = '25.05.12'
+__version__ = '25.05.26'
 
 
 class CartesianSphericalBase(CartesianBase):
@@ -592,7 +592,7 @@ def _intersecant2(c, r, p, b, radius=R_M, exact=False, height=None, wrap=False):
         p = _unrollon(c, p, wrap=wrap)
     nonexact = exact is None
 
-    if not isinstanceof(r, c.__class__, p.__class__):
+    if not isinstanceof(r, type(c), type(p)):
         r = Radius_(circle=r)
     elif nonexact:
         r = c.distanceTo(r, radius=radius, wrap=wrap)
@@ -601,7 +601,7 @@ def _intersecant2(c, r, p, b, radius=R_M, exact=False, height=None, wrap=False):
     else:
         raise _ValueError(exact=exact)
 
-    if not isinstanceof(b, c.__class__, p.__class__):
+    if not isinstanceof(b, type(c), type(p)):
         b = Bearing(b)
     elif nonexact:
         b = p.initialBearingTo(b, wrap=wrap)