pygeodesy 24.9.29__py2.py3-none-any.whl → 24.10.24__py2.py3-none-any.whl

pygeodesy/booleans.py

@@ -23,7 +23,7 @@ from pygeodesy.errors import ClipError, _IsnotError, _TypeError, \
                             _ValueError, _xattr, _xkwds_get, _xkwds_pop2
 from pygeodesy.fmath import favg, hypot, hypot2
 # from pygeodesy.fsums import fsum1  # _MODS
-from pygeodesy.interns import NN, _BANG_, _clip_, _clipid_, _COMMASPACE_, \
+from pygeodesy.interns import NN, _BANG_, _clipid_, _COMMASPACE_, \
                              _composite_, _DOT_, _duplicate_, _e_, \
                              _ELLIPSIS_, _few_, _height_, _lat_, _LatLon_, \
                              _lon_, _not_, _points_, _SPACE_, _too_, _X_, \
@@ -43,7 +43,7 @@ from pygeodesy.utily import fabs, _unrollon, _Wrap
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.booleans
-__version__ = '24.09.28'
+__version__ = '24.10.22'
 
 _0_EPS =  EPS  # near-zero, positive
 _EPS_0 = -EPS  # near-zero, negative
@@ -326,6 +326,21 @@ class LatLonFHP(_LatLonBool):
         _xscalar(other=other)
         return self.__class__(self.y * other, self.x * other)
 
+#   def _edge2(self):
+#       # Return the start and end point of the
+#       # edge containing I{intersection} C{v}.
+#       n = p = self
+#       while p.isintersection:
+#           p = p._prev
+#           if p is self:
+#               break
+#       while n.isintersection:
+#           n = n._next
+#           if n is self:
+#               break
+#       # assert p == self or not p._2Abs(self, n)
+#       return p, n
+
     def _e_x_str(self, t):  # PYCHOK no cover
         if self._label:
             t = NN(self._label, t)
@@ -417,21 +432,6 @@ class LatLonFHP(_LatLonBool):
                 n = n._next
         return p._prev, n
 
-#   def _edge2(self):
-#       # Return the start and end point of the
-#       # edge containing I{intersection} C{v}.
-#       n = p = self
-#       while p.isintersection:
-#           p = p._prev
-#           if p is self:
-#               break
-#       while n.isintersection:
-#           n = n._next
-#           if n is self:
-#               break
-#       # assert p == self or not p._2Abs(self, n)
-#       return p, n
-
     def _RPoracle(self, p1, p2, p3):
         # Relative Position oracle
         if p1._linked is self:  # or p1._linked2(self):
@@ -729,7 +729,7 @@ class _Clip(_Named):
             try:
                 i = cp._clips.index(self)
                 if i != self._id:
-                    kwds[_clip_] = i
+                    kwds.update(clip=i)
             except ValueError:
                 pass
             kwds[_clipid_] = self._id
@@ -1201,7 +1201,7 @@ class _CompositeFHP(_CompositeBase):
     def _clip(self, corners, Union=False, Clas=None,
                            **closed_inull_raiser_eps):
         # Clip this composite with another one, C{corners},
-        # using Foster-Hormann-Popa's algorithm.
+        # using the Foster-Hormann-Popa's algorithm.
         P = self
         Q = self._class(corners, closed_inull_raiser_eps,
                                  eps=P._eps, raiser=False)
@@ -1442,6 +1442,7 @@ class _CompositeGH(_CompositeBase):
                                  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
@@ -1546,7 +1547,7 @@ class _EdgeFHP(object):
             dq  = q2 - q1
             dq2 = dq * dq  # dot product, hypot2
             if dq2 > EPS2:  # like ._clip
-                T,  E  = None, _EdgeFHP  # self.__class__
+                T, _E  = None, _EdgeFHP  # self.__class__
                 p1, p2 = self._p1_p2
                 ap1   = p1._2A(q1, q2)
                 ap2_1 = p2._2A(q1, q2) - ap1
@@ -1558,10 +1559,10 @@ class _EdgeFHP(object):
                         a, a_0, a_0_1, _ = _alpha4(-ap1 / ap2_1)
                         b, b_0, b_0_1, _ = _alpha4(-aq1 / aq2_1)
                         # distinguish intersection types
-                        T = E.X_INTERSECT if a_0_1 and b_0_1 else (
-                            E.P_INTERSECT if a_0_1 and b_0   else (
-                            E.Q_INTERSECT if a_0   and b_0_1 else (
-                            E.V_INTERSECT if a_0   and b_0   else None)))
+                        T = _E.X_INTERSECT if a_0_1 and b_0_1 else (
+                            _E.P_INTERSECT if a_0_1 and b_0   else (
+                            _E.Q_INTERSECT if a_0   and b_0_1 else (
+                            _E.V_INTERSECT if a_0   and b_0   else None)))
 
                 elif fabs(ap1) < _0_EPS:  # parallel or colinear edges
                     dp = self._dp
@@ -1570,21 +1571,21 @@ class _EdgeFHP(object):
                     a, a_0, a_0_1, _a_0_1 = _alpha4((d1 * dp) / self._dp2)
                     b, b_0, b_0_1, _b_0_1 = _alpha4((d1 * dq) /     (-dq2))
                     # distinguish overlap type
-                    T = E.X_OVERLAP if  a_0_1 and  b_0_1 else (
-                        E.P_OVERLAP if  a_0_1 and _b_0_1 else (
-                        E.Q_OVERLAP if _a_0_1 and  b_0_1 else (
-                        E.V_OVERLAP if  a_0   and  b_0   else None)))
+                    T = _E.X_OVERLAP if  a_0_1 and  b_0_1 else (
+                        _E.P_OVERLAP if  a_0_1 and _b_0_1 else (
+                        _E.Q_OVERLAP if _a_0_1 and  b_0_1 else (
+                        _E.V_OVERLAP if  a_0   and  b_0   else None)))
 
                 if T:
-                    if T is E.X_INTERSECT:
+                    if T is _E.X_INTERSECT:
                         v = p1 + a * self._dp
                         yield T, (v, p1, p2, a), (v, q1, q2, b)
-                    elif T in E.Vs:
+                    elif T in _E.Vs:
                         yield T, (p1,), (q1,)
                     else:
-                        if T in E.Qs:
+                        if T in _E.Qs:
                             yield T, (p1,), (p1, q1, q2, b)
-                        if T in E.Ps:
+                        if T in _E.Ps:
                             yield T, (q1, p1, p2, a), (q1,)
 
 
@@ -1898,9 +1899,9 @@ def _alpha4(a):
     # Return 4-tuple (alpha, -EPS < alpha < EPS,
     #                           0 < alpha < 1,
     #                       not 0 < alpha < 1)
-    return (a, False, True,  False) if _0_EPS < a < _EPS_1 else (
-           (a, False, False, True)  if _0_EPS < fabs(a) else
-           (a, True,  False, False))
+    a_EPS = bool(_EPS_0 < a < _0_EPS)
+    a_0_1 = bool(_0_EPS < a < _EPS_1)
+    return a, a_EPS, a_0_1, (not a_0_1)
 
 
 def _Cps(Cp, composites_points, where):
@@ -1914,7 +1915,7 @@ def _Cps(Cp, composites_points, where):
 
 
 def _eps0(eps):
-    # Adjust C{eps} or C{None}.
+    # Adjust C{eps} or C{0}.
     return eps if eps and eps > EPS else 0
 
 
@@ -1930,7 +1931,7 @@ def isBoolean(obj):
 
 
 def _left_right_bottom_top_eps2(p1, p2):
-    '''(INTERNAL) Return 2-tuple C{(left, right), (bottom, top)}, oversized.
+    '''(INTERNAL) Return 2-tuple C{((left, right), (bottom, top))}, both oversized.
     '''
     return (_min_max_eps2(p1.x, p2.x),
             _min_max_eps2(p1.y, p2.y))
@@ -1939,18 +1940,23 @@ def _left_right_bottom_top_eps2(p1, p2):
 def _low_high_eps2(lo, hi, eps):
     '''(INTERNAL) Return 2-tuple C{(lo, hi)}, oversized.
     '''
-    lo *= (_1_0 + eps) if lo < 0 else (_1_0 - eps)
-    hi *= (_1_0 - eps) if hi < 0 else (_1_0 + eps)
-    return (lo or -eps), (hi or eps)
+    # assert eps > 0
+    lo -= fabs(eps * lo)
+    hi += fabs(eps * hi)
+    if lo < hi:
+        pass
+    elif lo > hi:
+        lo, hi = hi, lo
+    else:
+        lo -= eps
+        hi += eps
+    return lo, hi
 
 
 def _min_max_eps2(*xs):
     '''(INTERNAL) Return 2-tuple C{(min, max)}, oversized.
     '''
-    lo, hi = min(xs), max(xs)
-    lo *= _1_EPS if lo < 0 else _EPS_1
-    hi *= _EPS_1 if hi < 0 else _1_EPS
-    return (lo or _EPS_0), (hi or _0_EPS)
+    return _low_high_eps2(min(xs), max(xs), EPS)
 
 
 def _other(this, other):
@@ -1963,9 +1969,11 @@ def _other(this, other):
 
 
 def _outside(x1, x2, lo, hi):
-    '''(INTERNAL) Is C{(x1, x2)} outside C{(lo, hi)}?
+    '''(INTERNAL) Are C{x1} and C{x2} outside C{(lo, hi)}?
     '''
-    return max(x1, x2) < lo or min(x1, x2) > hi
+    # assert lo <= hi
+    return (x1 < lo or x2 > hi) if x1 > x2 else \
+           (x2 < lo or x1 > hi)
 
 
 __all__ += _ALL_DOCS(_BooleanBase, _Clip,

pygeodesy/cartesianBase.py

@@ -4,7 +4,7 @@
 u'''(INTERNAL) Private C{CartesianBase} class for elliposiodal, spherical and N-/vectorial
 C{Cartesian}s and public functions L{rtp2xyz}, L{rtp2xyz_}, L{xyz2rtp} and L{xyz2rtp_}.
 
-After I{(C) Chris Veness 2011-2015} published under the same MIT Licence**, see
+After I{(C) Chris Veness 2011-2024} published under the same MIT Licence**, see
 U{https://www.Movable-Type.co.UK/scripts/latlong.html},
 U{https://www.Movable-Type.co.UK/scripts/latlong-vectors.html} and
 U{https://www.Movable-Type.co.UK/scripts/geodesy/docs/latlon-ellipsoidal.js.html}.
@@ -43,7 +43,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 # from math import atan2, degrees, fabs, radians, sqrt  # from .fmath, .utily
 
 __all__ = _ALL_LAZY.cartesianBase
-__version__ = '24.08.18'
+__version__ = '24.10.12'
 
 _r_     = 'r'
 _theta_ = 'theta'

pygeodesy/constants.py

@@ -26,7 +26,7 @@ except ImportError:  # Python 2-
     _inf, _nan = float(_INF_), float(_NAN_)
 
 __all__ = _ALL_LAZY.constants
-__version__ = '24.09.28'
+__version__ = '24.10.15'
 
 
 def _copysign_0_0(y):
@@ -256,7 +256,8 @@ _K0_UTM  = _Float(_K0_UTM = 0.9996)  # PYCHOK in .etm, .ktm, .utm, UTM scale at
 # sqrt(2) <https://WikiPedia.org/wiki/Square_root_of_2>
 # 1.414213562373095_048_801_688_724_209_698_078_569_671_875_376_948_073_176_679_737_99
 # _1SQRT2= _Float(_1SQRT2 =sqrt(_2_0) + 1)
-_SQRT2_2 = _Float(_SQRT2_2=sqrt(_0_5))  # PYCHOK = 0.707106781186547_6 == sqrt(2) / 2
+# 0.707106781186547_524_400_844_362_104_849_039_284_835_937_688_474_036_588_339_868_99
+_SQRT2_2 = _Float(_SQRT2_2=sqrt(_0_5))  # PYCHOK = 0.707106781186547_5 == sqrt(2) / 2
 
 INF   =  Float(INF =_inf)    # PYCHOK INFinity, see function L{isinf}, L{isfinite}, NOT _Float!
 INT0  =  Int(  INT0= 0)      # PYCHOK unique int(0) instance, see .fsums, useZ=False
@@ -494,20 +495,23 @@ def _umod_PI2(rad):
 
 if __name__ == '__main__':
 
-    from pygeodesy import itemsorted, printf
-
-    t = n = v = []
-    for n, v in itemsorted(locals()):
-        if isinstance(v, (Float, Int, Radius)):
-            printf('%9s: %r', n, v.toRepr(std=False))
-            if v.name != n:
-                raise AssertionError('%r != %r' % (n, v))
-            if v.name is not n:
-                raise AssertionError('%r is not %r' % (n, v))
-            if not n.startswith(_UNDER_):
-                t.append(n)
-    t.append(float_.__name__)
-    printf('__all__ = %r', tuple(t))
+    def _main():
+        from pygeodesy import itemsorted, printf
+
+        t = n = v = []
+        for n, v in itemsorted(locals()):
+            if isinstance(v, (Float, Int, Radius)):
+                printf('%9s: %r', n, v.toRepr(std=False))
+                if v.name != n:
+                    raise AssertionError('%r != %r' % (n, v))
+                if v.name is not n:
+                    raise AssertionError('%r is not %r' % (n, v))
+                if not n.startswith(_UNDER_):
+                    t.append(n)
+        t.append(float_.__name__)
+        printf('__all__ = %r', tuple(t))
+
+    _main()
 
 # **) MIT License
 #

pygeodesy/datums.py

@@ -8,7 +8,7 @@ Classes L{Datum} and L{Transform} and registries L{Datums} and L{Transforms}, re
 Pure Python implementation of geodesy tools for ellipsoidal earth models, including datums
 and ellipsoid parameters for different geographic coordinate systems and methods for
 converting between them and to cartesian coordinates.  Transcoded from JavaScript originals by
-I{(C) Chris Veness 2005-2016} and published under the same MIT Licence**, see U{latlon-ellipsoidal.js
+I{(C) Chris Veness 2005-2024} and published under the same MIT Licence**, see U{latlon-ellipsoidal.js
 <https://www.Movable-Type.co.UK/scripts/geodesy/docs/latlon-ellipsoidal.js.html>}.
 
 Historical geodetic datums: a latitude/longitude point defines a geographic location on, above
@@ -94,7 +94,7 @@ from pygeodesy.units import _isRadius, Radius_,  radians
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.datums
-__version__ = '24.06.24'
+__version__ = '24.10.12'
 
 _a_ellipsoid_ = _UNDER_(_a_, _ellipsoid_)
 _BD72_        = 'BD72'
@@ -610,7 +610,7 @@ def _mean_radius(radius, *lats):
     return r
 
 
-def _negastr(name):  # in .trf
+def _negastr(name):  # in .trf, test/testTrf
     '''(INTERNAL) Negate a C{Transform/-Xform} name.
     '''
     b, m, p = _BAR_, _MINUS_, _PLUS_