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

pygeodesy/__init__.py

@@ -605,7 +605,7 @@ else:
 
 from pygeodesy.internals import _version2,  _DOT_  # noqa: E402
 # from pygeodesy.interns import _DOT_  # from .internals
-__version__ = '25.10.10'
+__version__ = '25.11.05'
 # see setup.py for similar logic
 version     = _DOT_(*_version2(__version__, n=3))
 

pygeodesy/booleans.py

@@ -45,7 +45,7 @@ from pygeodesy.utily import fabs, _unrollon, _Wrap
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.booleans
-__version__ = '25.09.04'
+__version__ = '25.10.30'
 
 _0EPS  =  EPS  # near-zero, positive
 _EPS0  = -EPS  # near-zero, negative
@@ -1434,17 +1434,14 @@ class _CompositeGH(_CompositeBase):
 
     def _clip(self, corners, s_entry, c_entry, Clas=None,
                            **closed_inull_raiser_xtend_eps):
-        # Clip this polygon with another one, C{corners}.
-
-        # Core of Greiner/Hormann's algorithm, enhanced U{Correia's
-        # <https://GitHub.com/helderco/univ-polyclip>} implementation***
-        # and extended to optionally handle so-called "degenerate cases"
+        # Clip this polygon with another one, C{corners}, using
+        # Greiner/Hormann's algorithm extended to optionally
+        # handle some so-called "degenerate cases"
         S = self
         C = self._class(corners, closed_inull_raiser_xtend_eps,
                                  raiser=False, xtend=False)
         bt = C._bottom_top_eps2
         lr = C._left_right_eps2
-
         # 1. find intersections
         for s1, s2, Sc in S._edges3(**closed_inull_raiser_xtend_eps):
             if not (_outside(s1.x, s2.x, *lr) or
@@ -1507,13 +1504,13 @@ class _CompositeGH(_CompositeBase):
 
     @property
     def xtend(self):
-        '''Get the option to handle I{degenerate cases} (C{bool}).
+        '''Get the option to handle some I{degenerate cases} (C{bool}).
         '''
         return self._xtend
 
     @xtend.setter  # PYCHOK setter!
     def xtend(self, xtend):
-        '''Set the option to handle I{degenerate cases} (C{bool}).
+        '''Set the option to handle some I{degenerate cases} (C{bool}).
         '''
         self._xtend = bool(xtend)
 
@@ -1825,9 +1822,7 @@ class BooleanFHP(_CompositeFHP, _BooleanBase):
 class BooleanGH(_CompositeGH, _BooleanBase):
     '''I{Composite} class providing I{boolean} operations between two
        I{composites} using the U{Greiner-Hormann<http://www.Inf.USI.CH/
-       hormann/papers/Greiner.1998.ECO.pdf>} algorithm and U{Correia
-       <https://GitHub.com/helderco/univ-polyclip>}'s implementation,
-       modified and extended.
+       hormann/papers/Greiner.1998.ECO.pdf>} algorithm, extended.
 
        The supported operations between (composite) polygon A and B are:
 
@@ -2003,23 +1998,3 @@ __all__ += _ALL_DOCS(_BooleanBase, _Clip,
 # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 # OTHER DEALINGS IN THE SOFTWARE.
-
-# ***) GNU GPL 3
-#
-# Copyright (C) 2011-2012 Helder Correia <Helder.MC@Gmail.com>
-#
-# This program is free software: you can redistribute it and/or
-# modify it under the terms of the GNU General Public License as
-# published by the Free Software Foundation, either version 3 of
-# the License, or any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.GNU.org/licenses/>.
-#
-# You should have received the README file along with this program.
-# If not, see <https://GitHub.com/helderco/univ-polyclip>.

pygeodesy/clipy.py

@@ -31,7 +31,7 @@ from pygeodesy.units import Bool, FIx, HeightX, Lat, Lon, Number_
 # from math import fabs  # from .fmath
 
 __all__ = _ALL_LAZY.clipy
-__version__ = '25.05.12'
+__version__ = '25.10.30'
 
 _fj_       = 'fj'
 _original_ = 'original'
@@ -237,9 +237,8 @@ def clipCS4(points, lowerleft, upperight, closed=False, inull=False):
 
 
 class ClipFHP4Tuple(_NamedTuple):
-    '''4-Tuple C{(lat, lon, height, clipid)} for each point of the
-       L{clipFHP4} result with the C{lat}-, C{lon}gitude, C{height}
-       and C{clipid} of the polygon or clip.
+    '''4-Tuple C{(lat, lon, height, clipid)} for each point of the L{clipFHP4} result
+       with the C{lat}-, C{lon}gitude, C{height} and C{clipid} of the polygon or clip.
 
        @note: The C{height} is a L{HeightX} instance if this point is
               an intersection, otherwise a L{Height} or C{int(0)}.
@@ -275,14 +274,13 @@ def clipFHP4(points, corners, closed=False, inull=False, raiser=False, eps=EPS):
                    as the B{C{points}} and B{C{corners}} coordinates).
 
        @return: Yield a L{ClipFHP4Tuple}C{(lat, lon, height, clipid)} for each
-                clipped point.  The result may consist of several clips, each
-                a (closed) polygon with a unique C{clipid}.
+                clipped point.  The result may consist of several I{clips}, each
+                a (closed) polygon with a unique C{clipid} identifier.
 
        @raise ClipError: Insufficient B{C{points}} or B{C{corners}} or an open clip.
 
        @see: U{Forster, Hormann and Popa<https://www.ScienceDirect.com/science/
-             article/pii/S259014861930007X>}, class L{BooleanFHP} and function
-             L{clipGH4}.
+             article/pii/S259014861930007X>} and class L{BooleanFHP}.
     '''
     P = _MODS.booleans._CompositeFHP(points, kind=_points_, raiser=raiser,
                                                    eps=eps, name__=clipFHP4)
@@ -292,12 +290,11 @@ def clipFHP4(points, corners, closed=False, inull=False, raiser=False, eps=EPS):
 
 
 class ClipGH4Tuple(ClipFHP4Tuple):
-    '''4-Tuple C{(lat, lon, height, clipid)} for each point of the
-       L{clipGH4} result with the C{lat}-, C{lon}gitude, C{height}
-       and C{clipid} of the polygon or clip.
+    '''4-Tuple C{(lat, lon, height, clipid)} for each point of the L{clipGH4} result
+       with the C{lat}-, C{lon}gitude, C{height} and C{clipid} of the polygon or clip.
 
-       @note: The C{height} is a L{HeightX} instance if this is
-              an intersection, otherwise a L{Height} or C{int(0)}.
+       @note: The C{height} is a L{HeightX} instance if this is an intersection,
+              otherwise a L{Height} or C{int(0)}.
     '''
     _Names_ = ClipFHP4Tuple._Names_
     _Units_ = ClipFHP4Tuple._Units_
@@ -305,8 +302,7 @@ class ClipGH4Tuple(ClipFHP4Tuple):
 
 def clipGH4(points, corners, closed=False, inull=False, raiser=True, xtend=False, eps=EPS):
     '''Clip one or more polygons against a clip region or box using the U{Greiner-Hormann
-       <http://www.Inf.USI.CH/hormann/papers/Greiner.1998.ECO.pdf>} algorithm, U{Correia
-       <https://GitHub.com/helderco/univ-polyclip>}'s implementation modified and extended.
+       <http://www.Inf.USI.CH/hormann/papers/Greiner.1998.ECO.pdf>} algorithm, extended.
 
        @arg points: The polygon points and clips (C{LatLon}[]).
        @arg corners: Three or more points defining the clip regions (C{LatLon}[])
@@ -320,19 +316,17 @@ def clipGH4(points, corners, closed=False, inull=False, raiser=True, xtend=False
                    as the B{C{points}} and B{C{corners}} coordinates).
 
        @return: Yield a L{ClipGH4Tuple}C{(lat, lon, height, clipid)} for each
-                clipped point.  The result may consist of several clips, each
-                a (closed) polygon with a unique C{clipid}.
+                clipped point.  The result may consist of several I{clips}, each
+                a (closed) polygon with a unique C{clipid} identifier.
 
        @raise ClipError: Insufficient B{C{points}} or B{C{corners}}, an open clip,
                          a I{degenerate case} or I{unhandled} intersection.
 
        @note: To handle I{degenerate cases} like C{point-edge} and C{point-point}
-              intersections, use function L{clipFHP4}.
+              intersections I{properly}, use function L{clipFHP4}.
 
-       @see: U{Greiner-Hormann<https://WikiPedia.org/wiki/Greiner–Hormann_clipping_algorithm>},
-             U{Ionel Daniel Stroe<https://Davis.WPI.edu/~matt/courses/clipping/>}, I{Correia}'s
-             U{univ-polyclip<https://GitHub.com/helderco/univ-polyclip>}, class L{BooleanGH}
-             and function L{clipFHP4}.
+       @see: U{Greiner-Hormann<https://WikiPedia.org/wiki/Greiner–Hormann_clipping_algorithm>}
+             and class L{BooleanGH}.
     '''
     S = _MODS.booleans._CompositeGH(points, raiser=raiser, xtend=xtend, eps=eps,
                                             name__=clipGH4, kind=_points_)

pygeodesy/constants.py

@@ -11,7 +11,7 @@ L{pygeodesy.isnon0} and L{pygeodesy.remainder}.
 from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _copysign, isbool, iscomplex, isint, signBit
-from pygeodesy.errors import _xError, _xError2, _xkwds_get1, _xkwds_item2
+from pygeodesy.errors import _ValueError, _xError, _xkwds_get1, _xkwds_item2
 # from pygeodesy.fsums import _isFsum_2Tuple  # _MODS
 from pygeodesy.internals import _0_0, _100_0, typename
 from pygeodesy.interns import _DMAIN_, _INF_, _NAN_
@@ -26,7 +26,7 @@ except ImportError:  # Python 2-
     _inf, _nan = float(_INF_), float(_NAN_)
 
 __all__ = _ALL_LAZY.constants
-__version__ = '25.09.11'
+__version__ = '25.10.15'
 
 
 def _copysign_0_0(y):
@@ -47,7 +47,7 @@ def _copysignINF(y):
     return NINF if signBit(y) else INF
 
 
-def _flipsign(x, y):
+def _flipsign(x, y=-1):
     '''(INTERNAL) Negate C{x} for negative C{y}.
     '''
     return (-x) if signBit(y) else x
@@ -60,65 +60,78 @@ def _Float(**name_arg):
     return Float(_float(arg), name=n)
 
 
-def _Radius(**name_arg):
-    '''(INTERNAL) New named, cached C{Radius}.
+def _float(x):  # in .datums, .ellipsoids, ...
+    '''(INTERNAL) Cache initial C{float}s.
     '''
-    n, arg = _xkwds_item2(name_arg)
-    return Radius(_float(arg), name=n)
+    f = float(x)
+    return _floats.setdefault(f, f)  # PYCHOK del _floats
 
 
-def float_(*fs, **sets):  # sets=False
-    '''Get scalars as C{float} or I{intern}'ed C{float}.
+def float_(x, sets=False):
+    '''Get scalar as C{float} or I{intern}'ed C{float}.
 
-       @arg fs: One more values (C{scalar}), all positional.
-       @kwarg sets: Use C{B{sets}=True} to C{intern} each
-                    B{C{fs}}, otherwise don't C{intern}.
+       @arg x: The scalar (C{scalar}).
+       @kwarg sets: Use C{True} to C{intern} the B{C{f}},
+                    otherwise don't (C{bool}).
 
-       @return: A single C{float} if only one B{C{fs}} is
-                given, otherwise a tuple of C{float}s.
+       @return: A C{float}.
 
-       @raise TypeError: Some B{C{fs}} is not C{scalar}.
+       @raise ValueError: Invalid B{C{x}}.
     '''
-    fl = []
-    _a =  fl.append
-    _f = _floats.setdefault if _xkwds_get1(sets, sets=False) else \
-         _floats.get
     try:
-        for i, f in enumerate(fs):
-            f = float(f)
-            _a(_f(f, f))
-    except Exception as x:
-        E, t = _xError2(x)
-        fs_i =  Fmt.SQUARE(fs=i)
-        raise E(fs_i, f, txt=t)
-    return fl[0] if len(fl) == 1 else tuple(fl)
-
-
-def _float(f):  # in .datums, .ellipsoids, ...
-    '''(INTERNAL) Cache initial C{float}s.
-    '''
-    f = float(f)
-    return _floats.setdefault(f, f)  # PYCHOK del _floats
+        f = float(x)
+        if f:
+            _f = _floats.setdefault if sets else _floats.get
+            f  = _f(f, f)
+        else:
+            f  = _N_0_0 if signBit(f) else _0_0
+    except Exception as X:
+        raise _ValueError(x=x, cause=X)
+    return f
 
 
 def float0_(*xs):
     '''Yield C{B{x}s} as a non-NEG0 C{float}.
     '''
     for x in xs:
-        yield float(x) if x else _0_0
+        yield float(x) or _0_0  # if x else _0_0
 
 
-def _float0(f):  # in .auxilats.auxily, .resections, .vector3dBase, ...
+def _float0(x):  # in .auxilats.auxily, .resections, .vector3dBase, ...
     '''(INTERNAL) Return C{float(B{f})} or C{INT0}.
     '''
-    if f:
-        f =  float(f)
+    if x:
+        f =  float(x)
         f = _floats.get(f, f)
-    elif f is not INT0:
-        f =  float(f) or _0_0  # force None, NN error
+    elif x is INT0:
+        f =  x
+    else:
+        f =  float(x) or _0_0  # force None, NN error
     return f
 
 
+def floats_(*xs, **sets):  # sets=False
+    '''Yield each scalar as C{float} or I{intern}'ed C{float}.
+
+       @arg xs: One more values (C{scalar}), all positional.
+       @kwarg sets: Use C{B{sets}=True} to C{intern} each
+                    B{C{fs}}, otherwise don't C{intern}.
+
+       @raise ValueError: Some B{C{xs}} is not C{scalar}.
+    '''
+    if sets:
+        sets = _xkwds_get1(sets, sets=False)
+    _f = _floats.setdefault if sets else _floats.get
+    try:
+        for i, x in enumerate(xs):
+            f = float(x)
+            yield _f(f, f) if f else \
+                  (_N_0_0 if signBit(f) else _0_0)  # preserve NEG0
+    except Exception as X:
+        xs_i = Fmt.SQUARE(xs=i)
+        raise _ValueError(xs_i, x, cause=X)
+
+
 def _floatuple(*fs):
     '''(INTERNAL) Cache a tuple of C{float}s.
     '''
@@ -172,6 +185,13 @@ def _1_over(x):
         return  NINF if isneg0(x) else INF
 
 
+def _Radius(**name_arg):
+    '''(INTERNAL) New named, cached C{Radius}.
+    '''
+    n, arg = _xkwds_item2(name_arg)
+    return Radius(_float(arg), name=n)
+
+
 _floats  = {}     # PYCHOK floats cache, in .__main__
 # _float = float  # PYCHOK expected
 # del _floats     # XXX zap floats cache never

pygeodesy/deprecated/__init__.py

@@ -27,7 +27,7 @@ __all__ = (_ALL_DEPRECATED.deprecated_bases +
            _ALL_DEPRECATED.deprecated_classes +
            _ALL_DEPRECATED.deprecated_consterns +
            _ALL_DEPRECATED.deprecated_functions)
-__version__ = '25.05.12'
+__version__ = '25.10.25'
 
 if _unLazy0:
     from pygeodesy.deprecated import bases, datum, nvector, rhumbBase, \

pygeodesy/deprecated/classes.py

@@ -18,11 +18,12 @@ from pygeodesy.namedTuples import Forward4Tuple as _Forward4Tuple, \
                                   UtmUps5Tuple  as _UtmUps5Tuple,  _NamedTuple
 from pygeodesy.props import deprecated_class, deprecated_method
 from pygeodesy.resections import TriAngle5Tuple as _TriAngle5Tuple
+from pygeodesy.triaxials import ConformalSphere, ConformalTriaxial, Conformal2Tuple
 from pygeodesy.trf import TRFXform7Tuple as _TRFXform7Tuple
 from pygeodesy.units import Bearing, Int, Lamd, Lat, Lon, Meter, Phid
 
 __all__ = _ALL_DEPRECATED.deprecated_classes
-__version__ = '25.04.11'
+__version__ = '25.10.25'
 
 
 class _Deprecated_NamedTuple(_NamedTuple):
@@ -235,6 +236,28 @@ def HeightIDWcosineForsytheAndoyerLambert(knots, **kwds):  # PYCHOK no cover
     return HeightIDWcosineForsytheAndoyerLambert(knots, **kwds)
 
 
+class JacobiConformal(ConformalTriaxial):
+    '''DEPRECATED on 2025.10.25, use class L{ConformalTriaxial}.'''
+    def __init__(self, *args, **kwds):  # PYCHOK no cover
+        deprecated_class(self.__class__)
+        ConformalTriaxial.__init__(self, *args, **kwds)
+
+
+class JacobiConformalSpherical(ConformalSphere):
+    '''DEPRECATED on 2025.10.25, use class L{ConformalSphere}.'''
+    def __init__(self, *args, **kwds):  # PYCHOK no cover
+        deprecated_class(self.__class__)
+        ConformalSphere.__init__(self, *args, **kwds)
+
+
+class Jacobi2Tuple(Conformal2Tuple):
+    '''DEPRECATED on 25.10.25, use class L{Conformal2Tuple}.
+    '''
+    def __new__(cls, *args, **kwds):
+        deprecated_class(cls)
+        return Conformal2Tuple.__new__(cls, *args, **kwds)
+
+
 class Lam_(Lamd):
     '''DEPRECATED on 2024.06.15, use class L{Lamd}.'''
     def __init__(self, *args, **kwds):  # PYCHOK no cover

pygeodesy/errors.py

@@ -28,7 +28,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _PYTHON_X_DEV
 from copy import copy as _copy
 
 __all__ = _ALL_LAZY.errors  # _ALL_DOCS('_InvalidError', '_IsnotError')  _under
-__version__ = '25.09.04'
+__version__ = '25.10.30'
 
 _argument_   = 'argument'
 _basics      = _MODS.into(basics=__name__)

pygeodesy/internals.py

@@ -498,7 +498,7 @@ def printf(fmt, *args, **nl_nt_prec_prefix__end_file_flush_sep__kwds):
             t =  fmt
     except Exception as x:
         _Error, s = _MODS.errors._xError2(x)
-        _unstr    = _MODS.strepr.unstr
+        _unstr    = _MODS.streprs.unstr
         t = _unstr(printf, fmt, *args, **nl_nt_prec_prefix__end_file_flush_sep__kwds)
         raise _Error(s, txt=t, cause=x)
     try:
@@ -709,7 +709,7 @@ def _versions(sep=_SPACE_):
 
 
 __all__ = tuple(map(typename, (machine, print_, printf, typename)))
-__version__ = '25.10.06'
+__version__ = '25.10.26'
 
 if __name__ == _DMAIN_:
 

pygeodesy/lazily.py

@@ -203,7 +203,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'INF', 'INT0', 'MANT_DIG', 'MAX', 'MAX_EXP', 'MIN', 'MIN_EXP', 'NAN', 'NEG0', 'NINF',
                                    'PI', 'PI2', 'PI_2', 'PI3', 'PI_3', 'PI3_2', 'PI4', 'PI_4', 'PI_6',
                                    'R_FM', 'R_GM', 'R_KM', 'R_M', 'R_MA', 'R_MB', 'R_NM', 'R_QM', 'R_SM', 'R_VM',
-                                   'float_', 'float0_', 'isclose', 'isfinite', 'isinf', 'isint0',
+                                   'float_', 'float0_', 'floats_', 'isclose', 'isfinite', 'isinf', 'isint0',
                                    'isnan', 'isnear0', 'isnear1', 'isnear90', 'isneg', 'isneg0', 'isninf', 'isnon0',
                                    'remainder'),
                          datums=_a('Datum', 'Datums', 'Transform', 'Transforms'),
@@ -346,9 +346,9 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'lrstrip', 'pairs', 'reprs', 'strs', 'unstr'),
                             trf=_a('RefFrame', 'RefFrames', 'TransformXform', 'TRFXform', 'TRFXform7Tuple',
                                    'date2epoch', 'epoch2date', 'trfTransform0', 'trfTransforms', 'trfXform'),
-                      triaxials=_a('BetaOmega2Tuple', 'BetaOmega3Tuple', 'Jacobi2Tuple',
-                                   'JacobiConformal', 'JacobiConformalSpherical',
-                                   'Triaxial', 'Triaxial_', 'TriaxialError', 'Triaxials', 'hartzell4'),
+                      triaxials=_a('BetaOmega2Tuple', 'BetaOmega3Tuple',
+                                   'ConformalSphere', 'ConformalTriaxial', 'Conformal2Tuple',
+                                   'Triaxial', 'Triaxial_', 'TriaxialError', 'Triaxials', 'hartzell4'),  # 'height4'
                           units=_a('Azimuth', 'Band', 'Bearing', 'Bearing_', 'Bool',
                                    'Degrees', 'Degrees_', 'Degrees2', 'Distance', 'Distance_', 'Easting', 'Epoch',
                                    'Feet', 'FIx', 'Float_', 'Height', 'Height_', 'HeightX', 'Int_',
@@ -394,6 +394,7 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                                          'HausdorffCosineAndoyerLambert', 'HausdorffCosineForsytheAndoyerLambert',
                                          'HeightIDW', 'HeightIDW2', 'HeightIDW3', 'HeightIDWcosineAndoyerLambert',
                                          'HeightIDWcosineForsytheAndoyerLambert', 'Helmert7Tuple',
+                                         'JacobiConformal', 'JacobiConformalSpherical', 'Jacobi2Tuple',
                                          'Lam_', 'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple',
                                          'Phi_', 'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple',
                                          'Transform7Tuple', 'TriAngle4Tuple', 'UtmUps4Tuple', 'XDist'),
@@ -511,7 +512,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '25.09.09'
+__version__ = '25.10.30'
 
 
 def _ALL_OTHER(*objs):