SYMBOL INDEX (6025 symbols across 189 files) FILE: docs/epydoc.js function toggle_private (line 1) | function toggle_private() { function show_private (line 52) | function show_private() { function getCookie (line 62) | function getCookie(name) { function setFrame (line 76) | function setFrame(url1, url2) { function checkCookie (line 80) | function checkCookie() { function toggleCallGraph (line 85) | function toggleCallGraph(id) { function expand (line 92) | function expand(id) { function collapse (line 105) | function collapse(id) { function toggle (line 131) | function toggle(id) { function highlight (line 140) | function highlight(id) { function num_lines (line 149) | function num_lines(s) { function collapse_all (line 160) | function collapse_all(min_lines) { function expandto (line 172) | function expandto(href) { function kill_doclink (line 190) | function kill_doclink(id) { function auto_kill_doclink (line 194) | function auto_kill_doclink(ev) { function doclink (line 202) | function doclink(id, name, targets_id) { function get_anchor (line 265) | function get_anchor() { function redirect_url (line 271) | function redirect_url(dottedName) { FILE: pygeodesy/__init__.py function _all (line 588) | def _all(globalocals): FILE: pygeodesy/__main__.py function _main (line 13) | def _main(): # PYCHOK no cover FILE: pygeodesy/albers.py function _ct2 (line 50) | def _ct2(s, c): function _Ks (line 57) | def _Ks(**name_k): function _Lat (line 63) | def _Lat(*lat, **Error_name_lat): function _qZx (line 70) | def _qZx(albs): class AlbersError (line 79) | class AlbersError(_ValueError): class _AlbersBase (line 87) | class _AlbersBase(_NamedBase): method __init__ (line 114) | def __init__(self, sa1, ca1, sa2, ca2, k, datum, **name): method _a_b_sxi3 (line 167) | def _a_b_sxi3(self, *ca_sa_ta_scb_4s): method _azik (line 185) | def _azik(self, t, ta): method _cstxif3 (line 191) | def _cstxif3(self, ta): method datum (line 200) | def datum(self): method ellipsoid (line 206) | def ellipsoid(self): method equatoradius (line 212) | def equatoradius(self): method flattening (line 220) | def flattening(self): method forward (line 227) | def forward(self, lat, lon, lon0=0, **name): method ispolar (line 281) | def ispolar(self): method _k0s (line 288) | def _k0s(self, k0): method lat0 (line 297) | def lat0(self): method lat1 (line 309) | def lat1(self): method lat2 (line 315) | def lat2(self): method majoradius (line 325) | def majoradius(self): # PYCHOK no cover method rescale0 (line 329) | def rescale0(self, lat, k=1): # PYCHOK no cover method reverse (line 344) | def reverse(self, x, y, lon0=0, LatLon=None, **name_LatLon_kwds): method scale0 (line 410) | def scale0(self): method _ta0 (line 418) | def _ta0(self, s1_qZ, ta0, E): method _ta0C2 (line 454) | def _ta0C2(self, ca1, sa1, ta1, ca2, sa2, ta2): method _tanf (line 488) | def _tanf(self, txi): # in .Ellipsoid.auxAuthalic method toRepr (line 508) | def toRepr(self, prec=6, **unused): # PYCHOK expected method toStr (line 519) | def toStr(self, prec=6, sep=_SPACE_, **unused): # PYCHOK expected method _txif (line 540) | def _txif(self, ta): # in .Ellipsoid.auxAuthalic class AlbersEqualArea (line 559) | class AlbersEqualArea(_AlbersBase): method __init__ (line 566) | def __init__(self, lat, k0=1, datum=_WGS84, **name): class AlbersEqualArea2 (line 582) | class AlbersEqualArea2(_AlbersBase): method __init__ (line 589) | def __init__(self, lat1, lat2, k1=1, datum=_WGS84, **name): class AlbersEqualArea4 (line 607) | class AlbersEqualArea4(_AlbersBase): method __init__ (line 615) | def __init__(self, slat1, clat1, slat2, clat2, k1=1, datum=_WGS84, **n... class AlbersEqualAreaCylindrical (line 641) | class AlbersEqualAreaCylindrical(_AlbersBase): method __init__ (line 647) | def __init__(self, lat=_0_0, datum=_WGS84, **name): class AlbersEqualAreaNorth (line 659) | class AlbersEqualAreaNorth(_AlbersBase): method __init__ (line 665) | def __init__(self, lat=_90_0, datum=_WGS84, **name): class AlbersEqualAreaSouth (line 677) | class AlbersEqualAreaSouth(_AlbersBase): method __init__ (line 683) | def __init__(self, lat=_N_90_0, datum=_WGS84, **name): class Albers7Tuple (line 695) | class Albers7Tuple(_NamedTuple): function _atanh1 (line 708) | def _atanh1(x): function _atanheE (line 729) | def _atanheE(x, E): # see Ellipsoid._es_atanh, .AuxLat._atanhee function _DatanheE (line 744) | def _DatanheE(x, y, E): # see .rhumb.ekx._DeatanhE function _D2atanheE (line 755) | def _D2atanheE(x, y, E): function _Dsn (line 783) | def _Dsn(x, y, sx, sy): function _tol (line 806) | def _tol(tol, x): function _1_x21 (line 812) | def _1_x21(x): function _xlat (line 818) | def _xlat(lat, f, where): FILE: pygeodesy/angles.py function _fint (line 54) | def _fint(f): function _ncardinal (line 60) | def _ncardinal(s, c, n): function _normalize2 (line 70) | def _normalize2(s, c): function _other (line 85) | def _other(x, unit=Radians, **unused): function _orthogonal2 (line 93) | def _orthogonal2(pred, s, c): function _raiseError (line 98) | def _raiseError(unit, arg, **kwds): function _rnd (line 102) | def _rnd(x): function _scnu4 (line 109) | def _scnu4(s, c, n, unit=Radians, **unused): # unit=Ang._unit class Ang (line 114) | class Ang(_Named): method __init__ (line 136) | def __init__(self, s_ang=0, c=None, n=0, normal=True, **unit_name): method __abs__ (line 164) | def __abs__(self): method __add__ (line 168) | def __add__(self, other): method __bool__ (line 171) | def __bool__(self): # PYCHOK Python 3+ method __ceil__ (line 178) | def __ceil__(self): # PYCHOK not special in Python 2- method __cmp__ (line 182) | def __cmp__(self, other): # PYCHOK no cover method __divmod__ (line 186) | def __divmod__(self, other): method __eq__ (line 191) | def __eq__(self, other): method __float__ (line 195) | def __float__(self): method __floor__ (line 202) | def __floor__(self): # PYCHOK not special in Python 2- method __floordiv__ (line 206) | def __floordiv__(self, other): method __ge__ (line 212) | def __ge__(self, other): method __gt__ (line 216) | def __gt__(self, other): method __hash__ (line 220) | def __hash__(self): # PYCHOK no cover method __iadd__ (line 225) | def __iadd__(self, other): method __ifloordiv__ (line 240) | def __ifloordiv__(self, other): method __imatmul__ (line 244) | def __imatmul__(self, other): # PYCHOK no cover method __imod__ (line 247) | def __imod__(self, other): method __imul__ (line 251) | def __imul__(self, other): method __int__ (line 255) | def __int__(self): method __invert__ (line 259) | def __invert__(self): # PYCHOK no cover method __ipow__ (line 263) | def __ipow__(self, other, *mod): # PYCHOK 2 vs 3 args method __isub__ (line 267) | def __isub__(self, other): method __itruediv__ (line 274) | def __itruediv__(self, other): method __le__ (line 278) | def __le__(self, other): method __lt__ (line 282) | def __lt__(self, other): method __matmul__ (line 286) | def __matmul__(self, other): # PYCHOK no cover method __mod__ (line 289) | def __mod__(self, other): method __mul__ (line 293) | def __mul__(self, other): method __ne__ (line 296) | def __ne__(self, other): method __neg__ (line 299) | def __neg__(self): method __pos__ (line 304) | def __pos__(self): method __pow__ (line 307) | def __pow__(self, other, *mod): # PYCHOK 2 vs 3 args method __radd__ (line 310) | def __radd__(self, other): method __rdivmod__ (line 313) | def __rdivmod__(self, other): method __repr__ (line 316) | def __repr__(self): method __rfloordiv__ (line 319) | def __rfloordiv__(self, other): method __rmatmul__ (line 322) | def __rmatmul__(self, other): # PYCHOK no cover method __rmod__ (line 325) | def __rmod__(self, other): method __rmul__ (line 328) | def __rmul__(self, other): method __round__ (line 331) | def __round__(self, *ndigits): # PYCHOK Python 3+ method __rpow__ (line 334) | def __rpow__(self, other, *mod): method __rsub__ (line 337) | def __rsub__(self, other): method __rtruediv__ (line 340) | def __rtruediv__(self, other): method __str__ (line 343) | def __str__(self): method __sub__ (line 346) | def __sub__(self, other): method __truediv__ (line 349) | def __truediv__(self, other): method _Ang (line 362) | def _Ang(self, s, *cn, **normal_unit_name): method base (line 366) | def base(self, *center): method c (line 381) | def c(self): method cardinal (line 387) | def cardinal(q=0, **unit_name): method copy (line 412) | def copy(self, **unit_name): # PYCHOK signature method degrees (line 418) | def degrees(self): method degrees0 (line 427) | def degrees0(self): method EPS0 (line 435) | def EPS0(**unit_name): method _flip (line 445) | def _flip(bet, omg, alp=None): method flipsign (line 453) | def flipsign(self, mul=-1, **name): method _float1 (line 459) | def _float1(self, f, **name): method _float2 (line 463) | def _float2(self, other=None): method _ifloat (line 469) | def _ifloat(self, f): # PYCHOK expected method fromDegrees (line 476) | def fromDegrees(deg, **unit_name): method fromLambertian (line 493) | def fromLambertian(psi, **unit_name): method fromRadians (line 500) | def fromRadians(rad, **unit_name): method fromScalar (line 517) | def fromScalar(ang, **unit_name): method is_integer (line 534) | def is_integer(self, *n): method isnear0 (line 539) | def isnear0(self, eps0=EPS0): # aka zerop method _kwds (line 545) | def _kwds(self, kwds, **dflt): method lambertian (line 550) | def lambertian(self): method mod (line 555) | def mod(self, mul=_1_0, **unit_name): method N (line 577) | def N(**unit_name): method n (line 583) | def n(self): method n (line 589) | def n(self, n): method _n_0 (line 592) | def _n_0(self, n): method n0 (line 601) | def n0(self): method n0 (line 607) | def n0(self, n): method _n01 (line 611) | def _n01(self): method NAN (line 616) | def NAN(**unit_name): method ncardinal (line 622) | def ncardinal(self): method nearest (line 629) | def nearest(self, ind=0, **name): method _norm (line 643) | def _norm(bet, omg, alp=None, alt=False): method normalize (line 651) | def normalize(self, *n): method _other (line 662) | def _other(self, other): method _quadrant (line 669) | def _quadrant(self): method quadrant (line 674) | def quadrant(self): method quadrant (line 678) | def quadrant(self, quadrant): method radians (line 688) | def radians(self): method radians0 (line 697) | def radians0(self): method reflect (line 702) | def reflect(self, flips=False, flipc=False, swapsc=False): method round (line 721) | def round(self, *ndigits, **name): method s (line 733) | def s(self): method sc2 (line 739) | def sc2(self): method scn3 (line 745) | def scn3(self): method scnu4 (line 751) | def scnu4(self): method shift (line 756) | def shift(self, q=0, **unit_name): method signOf (line 768) | def signOf(self, *n): method t (line 776) | def t(self): method toDegrees (line 781) | def toDegrees(self, *n): method toLambertian (line 793) | def toLambertian(self, **name): method toRadians (line 799) | def toRadians(self, *n): method toRepr (line 811) | def toRepr(self, *n, **prec_fmt): # PYCHOK signature method toStr (line 816) | def toStr(self, *n, **prec_fmt): # PYCHOK signature method toTuple (line 821) | def toTuple(self, **prec_fmt_sep): method toUnit (line 826) | def toUnit(self, *n): method unit (line 836) | def unit(self): method unit (line 840) | def unit(self, unit): method _update (line 846) | def _update(self, *sc): class _Ang3Tuple (line 857) | class _Ang3Tuple(_NamedTuple): method toDegrees (line 863) | def toDegrees(self, *n, **fmt_prec_sep): method toLambertian (line 874) | def toLambertian(self): method toRadians (line 879) | def toRadians(self, *n): method toUnit (line 884) | def toUnit(self, unit, *n): class Lambertian (line 895) | class Lambertian(Radians): method __new__ (line 898) | def __new__(cls, *args, **kwds): function Ang_ (line 908) | def Ang_(s, c=None, n=1, **unit_name): function Deg (line 914) | def Deg(deg, **name): function isAng (line 920) | def isAng(ang): function Rad (line 926) | def Rad(rad, **name): function _SinCos2 (line 932) | def _SinCos2(ang, *unit): FILE: pygeodesy/auxilats/_CX_Rs.py class _Rcoeffs (line 28) | class _Rcoeffs(ADict): method __init__ (line 31) | def __init__(self, ALorder, coeffs): method bnuz4 (line 50) | def bnuz4(self): # in .auxilats.__main__ # PYCHOK no cover method items (line 64) | def items(self): # string-ify keys # PYCHOK no cover method _Rtuples (line 68) | def _Rtuples(self): # PYCHOK no cover method _validate (line 75) | def _validate(self, aL, lenAux): class _Rdict (line 85) | class _Rdict(dict): # in ._CX_#, .auxLat, .rhumb.aux_ method __init__ (line 90) | def __init__(self, nt, *Rtuples): method _floats (line 108) | def _floats(self, rs): method _floatuple (line 124) | def _floatuple(self, Rtuple): class _Rkey (line 137) | class _Rkey(int): method __new__ (line 140) | def __new__(cls, k): class _RsError (line 148) | class _RsError(_AssertionError): method __init__ (line 151) | def __init__(self, *rs, **kwds_cause): # PYCHOK no cover class _Rtuple (line 162) | class _Rtuple(list): # MUST be list, NOT tuple! method __init__ (line 168) | def __init__(self, k, n, *rs): method __getitem__ (line 187) | def __getitem__(self, i): method __getslice__ (line 191) | def __getslice__(self, *i_j): # PYCHOK 3 args method __iter__ (line 194) | def __iter__(self): method __len__ (line 197) | def __len__(self): method _tuple (line 201) | def _tuple(self): method append (line 215) | def append(self, arg): method extend (line 218) | def extend(self, arg): FILE: pygeodesy/auxilats/__main__.py function _main (line 11) | def _main(**ALorder): # PYCHOK no cover FILE: pygeodesy/auxilats/auxAngle.py class AuxAngle (line 41) | class AuxAngle(_Named): method __init__ (line 51) | def __init__(self, y_angle=_0_0, x=_1_0, aux=None, **name): method __abs__ (line 82) | def __abs__(self): method __add__ (line 89) | def __add__(self, other): method __bool__ (line 101) | def __bool__(self): # PYCHOK not special in Python 2- method __eq__ (line 106) | def __eq__(self, other): method __float__ (line 111) | def __float__(self): method __iadd__ (line 116) | def __iadd__(self, other): method __isub__ (line 127) | def __isub__(self, other): method __ne__ (line 138) | def __ne__(self, other): method __neg__ (line 147) | def __neg__(self): method __pos__ (line 157) | def __pos__(self): method __radd__ (line 162) | def __radd__(self, other): method __rsub__ (line 170) | def __rsub__(self, other): method __str__ (line 178) | def __str__(self): method __sub__ (line 182) | def __sub__(self, other): method _iadd (line 194) | def _iadd(self, other, *unused): # op method _copy_2 (line 206) | def _copy_2(self, which): method _copy_r2 (line 211) | def _copy_r2(self, other, which): method copyquadrant (line 217) | def copyquadrant(self, other): method diff (line 226) | def diff(self): method fromDegrees (line 232) | def fromDegrees(deg, **aux_name): method fromLambertianDegrees (line 238) | def fromLambertianDegrees(psi, **aux_name): method fromLambertianRadians (line 244) | def fromLambertianRadians(psi, **aux_name): method fromRadians (line 250) | def fromRadians(rad, **aux_name): method iteration (line 256) | def iteration(self): method normal (line 261) | def normal(self): method normalized (line 270) | def normalized(self): method _RhumbAux (line 277) | def _RhumbAux(self): method tan (line 283) | def tan(self): method toBeta (line 289) | def toBeta(self, rhumb): method toChi (line 294) | def toChi(self, rhumb): method toDegrees (line 300) | def toDegrees(self): method toLambertianDegrees (line 306) | def toLambertianDegrees(self): # PYCHOK no cover method toLambertianRadians (line 313) | def toLambertianRadians(self): method toMu (line 318) | def toMu(self, rhumb): method toPhi (line 323) | def toPhi(self, rhumb): method toRadians (line 329) | def toRadians(self): method _toRhumbAux (line 334) | def _toRhumbAux(self, rhumb, aux): method x (line 341) | def x(self): method x (line 347) | def x(self, x): # PYCHOK no cover method _x_normalized (line 356) | def _x_normalized(self): method y (line 363) | def y(self): method y (line 369) | def y(self, y): # PYCHOK no cover method _yx (line 378) | def _yx(self): method _yx (line 384) | def _yx(self, yx): method _yx_normalized (line 393) | def _yx_normalized(self): method _yxr_normalized (line 414) | def _yxr_normalized(self, abs_y=False): class AuxBeta (line 424) | class AuxBeta(AuxAngle): method fromDegrees (line 430) | def fromDegrees(deg, **name): method fromRadians (line 436) | def fromRadians(rad, **name): class AuxChi (line 442) | class AuxChi(AuxAngle): method fromDegrees (line 448) | def fromDegrees(deg, **name): class AuxMu (line 454) | class AuxMu(AuxAngle): method fromDegrees (line 460) | def fromDegrees(deg, **name): class AuxPhi (line 466) | class AuxPhi(AuxAngle): method fromDegrees (line 473) | def fromDegrees(deg, **name): class AuxTheta (line 479) | class AuxTheta(AuxAngle): method fromDegrees (line 485) | def fromDegrees(deg, **name): class AuxXi (line 491) | class AuxXi(AuxAngle): method fromDegrees (line 497) | def fromDegrees(deg, **name): function _AuxClass (line 511) | def _AuxClass(aux=None, **unused): # PYCHOK C{classof(aux)} function _yx2 (line 515) | def _yx2(yx): FILE: pygeodesy/auxilats/auxDLat.py class AuxDLat (line 32) | class AuxDLat(AuxLat): method CParametric (line 38) | def CParametric(self, Zeta1, Zeta2): method CRectifying (line 43) | def CRectifying(self, Zeta1, Zeta2): method _Datanhee (line 48) | def _Datanhee(self, x, y): method Dconvert (line 66) | def Dconvert(self, auxout, Zeta1, Zeta2): method DE (line 82) | def DE(self, X, Y): method DIsometric (line 115) | def DIsometric(self, Phi1, Phi2): method DParametric (line 128) | def DParametric(self, Phi1, Phi2): method DRectifying (line 161) | def DRectifying(self, Phi1, Phi2): function _DClenshaw (line 183) | def _DClenshaw(sinp, Zeta1, Zeta2, cs, K): function _Dsin (line 244) | def _Dsin(x, y): # see also .rhumb.ekx._Dsin function _Dsn (line 252) | def _Dsn(x, y): function _sxk2y (line 269) | def _sxk2y(sx, sy, k2): FILE: pygeodesy/auxilats/auxDST.py class AuxDST (line 30) | class AuxDST(object): method __init__ (line 38) | def __init__(self, N): method evaluate (line 48) | def evaluate(sinx, cosx, F, *N): method _fft_numpy (line 78) | def _fft_numpy(self): method _fft_real (line 83) | def _fft_real(self, data): method _ffts (line 90) | def _ffts(self, data, cIV): method _ffts2 (line 126) | def _ffts2(self, data, F): method integral (line 146) | def integral(sinx, cosx, F, *N): method integral2 (line 172) | def integral2(sinx, cosx, siny, cosy, F, *N): # PYCHOK no cover method N (line 208) | def N(self): method refine (line 213) | def refine(self, f, F, *sentinel): method reset (line 233) | def reset(self, N): method transform (line 244) | def transform(self, f): function _len_N (line 262) | def _len_N(F, *N): function _reverscaled (line 267) | def _reverscaled(F, *N): FILE: pygeodesy/auxilats/auxLat.py function _exp2 (line 47) | def _exp2(x): class AuxLat (line 56) | class AuxLat(AuxAngle): method __init__ (line 73) | def __init__(self, a_earth=_EWGS84, f=None, b=None, **ALorder_name): method a (line 112) | def a(self): method ALorder (line 120) | def ALorder(self): method ALorder (line 126) | def ALorder(self, order): method _atanhee (line 134) | def _atanhee(self, tphi): # see Ellipsoid._es_atanh, .albers._atanhee method Authalic (line 143) | def Authalic(self, Phi, **diff_name): method AuthalicRadius2 (line 177) | def AuthalicRadius2(self, exact=False, f_max=_0_1): method b (line 207) | def b(self): method _coeffs (line 214) | def _coeffs(self, auxout, auxin): method Conformal (line 253) | def Conformal(self, Phi, **diff_name): method _conformal_diff (line 328) | def _conformal_diff(self): # PYCHOK no cover method convert (line 342) | def convert(self, auxout, Zeta_d, exact=False): method _CXcoeffs (line 381) | def _CXcoeffs(self): # in .auxilats.__main__, .testAuxilats method _Dq (line 386) | def _Dq(self, tphi): method _e (line 419) | def _e(self): # unsigned, (1st) eccentricity method _e1 (line 423) | def _e1(self): method _e12 (line 427) | def _e12(self): method _e12p1 (line 431) | def _e12p1(self): method _e2 (line 435) | def _e2(self): # signed, (1st) eccentricity squared method _e2m1 (line 439) | def _e2m1(self): # 1 less 1st eccentricity squared method _e2m1_sq2 (line 443) | def _e2m1_sq2(self): method _2_e2m12 (line 447) | def _2_e2m12(self): method _Ef_fRG_a2b2_PI_4 (line 451) | def _Ef_fRG_a2b2_PI_4(self): method ellipsoid (line 456) | def ellipsoid(self): method f (line 462) | def f(self): method _fm1 (line 470) | def _fm1(self): # 1 - flattening method _fromAux (line 473) | def _fromAux(self, Zeta, **name): method _fromAuxCase (line 498) | def _fromAuxCase(self): method Geocentric (line 508) | def Geocentric(self, Phi, **diff_name): method Geodetic (line 525) | def Geodetic(self, Phi, **name): # PYCHOK no cover method _n (line 539) | def _n(self): # 3rd flattening method _n2 (line 543) | def _n2(self): method Parametric (line 546) | def Parametric(self, Phi, **diff_name): method _q (line 566) | def _q(self): # constant _q method _qf (line 575) | def _qf(self, tphi): method _qIntegrand (line 580) | def _qIntegrand(self, beta): method Rectifying (line 605) | def Rectifying(self, Phi, **diff_name): method RectifyingRadius (line 665) | def RectifyingRadius(self, exact=False): method _RectifyingR (line 678) | def _RectifyingR(self): method _scbeta (line 683) | def _scbeta(self, tphi): method _toAux (line 686) | def _toAux(self, auxout, Phi, **diff_name): method _toZeta (line 709) | def _toZeta(self, zetaux): function _Clenshaw (line 747) | def _Clenshaw(sinp, Zeta, cs, K): function _diff_name2 (line 770) | def _diff_name2(Phi, diff=False, **name): function _Newton (line 777) | def _Newton(tphi, Zeta, _toZeta, **name): FILE: pygeodesy/auxilats/auxily.py class Aux (line 35) | class Aux(object): method __index__ (line 48) | def __index__(self, aux): method __len__ (line 52) | def __len__(self): method _CXcoeffs (line 55) | def _CXcoeffs(self, aL): # in .auxLat.AuxLat._CXcoeffs method _1d (line 70) | def _1d(self, auxout, auxin): method Greek (line 78) | def Greek(self, aux): method len (line 83) | def len(self, ALorder): # PYCHOK no cover method power (line 90) | def power(self, auxout, auxin): method use_n2 (line 96) | def use_n2(self, aux): function _Dasinh (line 111) | def _Dasinh(x, y): function _Datan (line 135) | def _Datan(x, y): function _Dh (line 153) | def _Dh(x, y): function _Dlam (line 177) | def _Dlam(x, y): # Chi1.tan, Chi2.tan function _Dm (line 191) | def _Dm(X, Y, s): # in .auxDLat, .auxDST function _Dp0Dpsi (line 198) | def _Dp0Dpsi(x, y): # Chi1.tan, Chi2.tan function _h (line 216) | def _h(tx): function _sn (line 224) | def _sn(tx): FILE: pygeodesy/azimuthal.py function _enzh4 (line 81) | def _enzh4(x, y, *h): class _AzimuthalBase (line 90) | class _AzimuthalBase(_NamedBase): method __init__ (line 102) | def __init__(self, lat0, lon0, datum=None, **name): method datum (line 125) | def datum(self): method equatoradius (line 131) | def equatoradius(self): method flattening (line 139) | def flattening(self): method forward (line 146) | def forward(self, lat, lon, **name): # PYCHOK no cover method _forward (line 150) | def _forward(self, lat, lon, name, _k_t): method _forwards (line 170) | def _forwards(self, *lls): method lat0 (line 178) | def lat0(self): method latlon0 (line 184) | def latlon0(self): method latlon0 (line 190) | def latlon0(self, latlon0): method lon0 (line 204) | def lon0(self): method majoradius (line 210) | def majoradius(self): # PYCHOK no cover method radius (line 215) | def radius(self): method reset (line 220) | def reset(self, lat0, lon0): method _reset (line 231) | def _reset(self, lat0, lon0): method reverse (line 238) | def reverse(self, x, y, **name_LatLon_and_kwds): method _reverse (line 242) | def _reverse(self, x, y, _c, lea, LatLon=None, **name_LatLon_kwds): method _reverse2 (line 272) | def _reverse2(self, x_t, *y): method _toLatLon (line 280) | def _toLatLon(self, lat, lon, LatLon, name_LatLon_kwds): method toRepr (line 289) | def toRepr(self, prec=6, **unused): # PYCHOK expected method toStr (line 299) | def toStr(self, prec=6, sep=_SPACE_, **unused): # PYCHOK expected class AzimuthalError (line 311) | class AzimuthalError(_ValueError): class Azimuthal7Tuple (line 319) | class Azimuthal7Tuple(_NamedTuple): method antipodal (line 330) | def antipodal(self, azimuth=None): class Equidistant (line 341) | class Equidistant(_AzimuthalBase): method forward (line 354) | def forward(self, lat, lon, **name): method reverse (line 384) | def reverse(self, x, y, **name_LatLon_and_kwds): function equidistant (line 408) | def equidistant(lat0, lon0, datum=_WGS84, exact=False, geodsolve=False, ... class _AzimuthalGeodesic (line 442) | class _AzimuthalGeodesic(_AzimuthalBase): method geodesic (line 451) | def geodesic(self): # PYCHOK no cover method _7Tuple (line 455) | def _7Tuple(self, e, n, r, name_LatLon_kwds, M=None): class _EquidistantBase (line 466) | class _EquidistantBase(_AzimuthalGeodesic): method __init__ (line 470) | def __init__(self, lat0, lon0, datum=_WGS84, **name): method forward (line 480) | def forward(self, lat, lon, **name): method reverse (line 503) | def reverse(self, x, y, LatLon=None, **name_LatLon_kwds): # PYCHOK si... class EquidistantExact (line 528) | class EquidistantExact(_EquidistantBase): method __init__ (line 543) | def __init__(self, lat0, lon0, datum=_WGS84, **name): method geodesic (line 562) | def geodesic(self): class EquidistantGeodSolve (line 568) | class EquidistantGeodSolve(_EquidistantBase): method __init__ (line 576) | def __init__(self, lat0, lon0, datum=_WGS84, **name): method geodesic (line 595) | def geodesic(self): class EquidistantKarney (line 601) | class EquidistantKarney(_EquidistantBase): method __init__ (line 608) | def __init__(self, lat0, lon0, datum=_WGS84, **name): method geodesic (line 630) | def geodesic(self): class Gnomonic (line 643) | class Gnomonic(_AzimuthalBase): method forward (line 651) | def forward(self, lat, lon, **name): method reverse (line 673) | def reverse(self, x, y, **name_LatLon_and_kwds): function gnomonic (line 697) | def gnomonic(lat0, lon0, datum=_WGS84, exact=False, geodsolve=False, **n... class _GnomonicBase (line 731) | class _GnomonicBase(_AzimuthalGeodesic): method __init__ (line 735) | def __init__(self, lat0, lon0, datum=_WGS84, **name): method forward (line 743) | def forward(self, lat, lon, raiser=True, **name): # PYCHOK signature method reverse (line 781) | def reverse(self, x, y, LatLon=None, **name_LatLon_kwds): # PYCHOK si... class GnomonicExact (line 836) | class GnomonicExact(_GnomonicBase): method __init__ (line 844) | def __init__(self, lat0, lon0, datum=_WGS84, **name): method geodesic (line 863) | def geodesic(self): class GnomonicGeodSolve (line 869) | class GnomonicGeodSolve(_GnomonicBase): method __init__ (line 877) | def __init__(self, lat0, lon0, datum=_WGS84, **name): method geodesic (line 896) | def geodesic(self): class GnomonicKarney (line 902) | class GnomonicKarney(_GnomonicBase): method __init__ (line 909) | def __init__(self, lat0, lon0, datum=_WGS84, **name): method geodesic (line 931) | def geodesic(self): class LambertEqualArea (line 940) | class LambertEqualArea(_AzimuthalBase): method forward (line 949) | def forward(self, lat, lon, **name): method reverse (line 972) | def reverse(self, x, y, **name_LatLon_and_kwds): class Orthographic (line 996) | class Orthographic(_AzimuthalBase): method forward (line 1004) | def forward(self, lat, lon, **name): method reverse (line 1024) | def reverse(self, x, y, **name_LatLon_and_kwds): class Stereographic (line 1047) | class Stereographic(_AzimuthalBase): method forward (line 1058) | def forward(self, lat, lon, **name): method k0 (line 1082) | def k0(self): method k0 (line 1088) | def k0(self, factor): method reverse (line 1095) | def reverse(self, x, y, **name_LatLon_and_kwds): FILE: pygeodesy/basics.py function _Xstr (line 74) | def _Xstr(exc): # PYCHOK no cover function str2ub (line 99) | def str2ub(sb): function ub2str (line 106) | def ub2str(ub): function _args_kwds_names (line 139) | def _args_kwds_names(func, splast=False): function clips (line 164) | def clips(sb, limit=50, white=NN, length=False): function copysign0 (line 186) | def copysign0(x, y): function copytype (line 195) | def copytype(x, y): function _enumereverse (line 203) | def _enumereverse(iterable): function _gcd (line 214) | def _gcd(a, b): # PYCHOK redef function halfs2 (line 226) | def halfs2(str2): function _integer_ratio2 (line 241) | def _integer_ratio2(x): # PYCHOK no cover function int1s (line 250) | def int1s(x): # PYCHOK no cover function isbool (line 262) | def isbool(obj): function isCartesian (line 275) | def isCartesian(obj, ellipsoidal=None): function isclass (line 294) | def isclass(obj): # XXX avoid epydoc Python 2.7 error function iscomplex (line 300) | def iscomplex(obj, both=False): function isDEPRECATED (line 315) | def isDEPRECATED(obj, outer=1): function isfloat (line 334) | def isfloat(obj, both=False): function isidentifier (line 353) | def isidentifier(obj): function _isin (line 361) | def _isin(obj, *objs): function isinstanceof (line 368) | def isinstanceof(obj, *Classes): function isint (line 380) | def isint(obj, both=False): function isiterable (line 403) | def isiterable(obj, strict=False): function isiterablen (line 415) | def isiterablen(obj, strict=False): function isiterabletype (line 427) | def isiterabletype(obj, method='__iter__'): function iskeyword (line 451) | def iskeyword(unused): function isLatLon (line 457) | def isLatLon(obj, ellipsoidal=None): function islistuple (line 476) | def islistuple(obj, minum=0): function isNvector (line 488) | def isNvector(obj, ellipsoidal=None): function isodd (line 507) | def isodd(x): function isscalar (line 517) | def isscalar(obj, both=False): function issequence (line 534) | def issequence(obj, *excls): function isstr (line 547) | def isstr(obj): function issubclassof (line 558) | def issubclassof(Sub, *Supers): function itemsorted (line 575) | def itemsorted(adict, *items_args, **asorted_reverse): function len2 (line 596) | def len2(items): function map1 (line 610) | def map1(fun1, *xs): # XXX map_ function map2 (line 622) | def map2(fun, *xs, **strict): function max2 (line 640) | def max2(*xs): function _max2min2 (line 646) | def _max2min2(xs, _m, _m2): function min2 (line 661) | def min2(*xs): function neg (line 667) | def neg(x, neg0=None): function neg_ (line 684) | def neg_(*xs): function _neg0 (line 692) | def _neg0(x): function _req_d_by (line 699) | def _req_d_by(where, **name): function _reverange (line 710) | def _reverange(n, stop=-1, step=-1): function signBit (line 720) | def signBit(x): function _signOf (line 728) | def _signOf(x, ref): # in .fsums function signOf (line 734) | def signOf(x): function splice (line 746) | def splice(iterable, n=2, **fill): function _splituple (line 804) | def _splituple(strs, *sep_splits): # in .mgrs, ... function unsigned0 (line 817) | def unsigned0(x): function _xcopy (line 825) | def _xcopy(obj, deep=False): function _xcoverage (line 837) | def _xcoverage(where, *required): # in .__main__ # PYCHOK no cover function _xdup (line 848) | def _xdup(obj, deep=False, **items): function _xgeographiclib (line 873) | def _xgeographiclib(where, *required): function _xImportError (line 884) | def _xImportError(exc, where, Error=_ImportError, **name): function _xinstanceof (line 891) | def _xinstanceof(*Types, **names_values): function _xiterable (line 910) | def _xiterable(obj): function _xiterablen (line 916) | def _xiterablen(obj): function _xiterror (line 922) | def _xiterror(obj, _xwhich): function _xnumpy (line 929) | def _xnumpy(where, *required): function _xor (line 940) | def _xor(x, *xs): function _xpackages (line 948) | def _xpackages(_xhich): function _xscalar (line 960) | def _xscalar(**names_values): function _xscipy (line 968) | def _xscipy(where, *required): function _xsubclassof (line 979) | def _xsubclassof(*Classes, **names_values): function _xversion (line 998) | def _xversion(package, where, *required, **name): function _xzip (line 1012) | def _xzip(*args, **strict): # PYCHOK no cover function _zip (line 1028) | def _zip(*args): FILE: pygeodesy/booleans.py function _Cnum (line 63) | def _Cnum(txt, enum): # PYCHOK unused class _L (line 67) | class _L(object): # Intersection labels class _RP (line 90) | class _RP(object): # RelativePositions class _LatLonBool (line 115) | class _LatLonBool(_Named): method __init__ (line 128) | def __init__(self, lat_ll, lon=None, height=0, clipid=INT0, wrap=False... method __abs__ (line 159) | def __abs__(self): method __eq__ (line 162) | def __eq__(self, other): method __ne__ (line 167) | def __ne__(self, other): # required for Python 2 # PYCHOK no cover method __repr__ (line 170) | def __repr__(self): method __str__ (line 180) | def __str__(self): method __sub__ (line 200) | def __sub__(self, other): method _2A (line 205) | def _2A(self, p2, p3): method _2Abs (line 211) | def _2Abs(self, p2, p3, eps=_10EPS): method clipid (line 218) | def clipid(self): method _equi (line 223) | def _equi(self, llb, eps): method height (line 230) | def height(self): method isequalTo (line 237) | def isequalTo(self, other, eps=None): method isintersection (line 254) | def isintersection(self): method ispoint (line 260) | def ispoint(self): method lat (line 266) | def lat(self): method latlon (line 272) | def latlon(self): method _link (line 277) | def _link(self, other): method lon (line 284) | def lon(self): method _toClas (line 289) | def _toClas(self, Clas, clipid): class LatLonFHP (line 295) | class LatLonFHP(_LatLonBool): method __init__ (line 303) | def __init__(self, lat_ll, lon=None, height=0, clipid=INT0, **wrap_name): method __add__ (line 315) | def __add__(self, other): method __mod__ (line 319) | def __mod__(self, other): # cross product method __mul__ (line 323) | def __mul__(self, other): # dot product method __rmul__ (line 327) | def __rmul__(self, other): # scalar product method _e_x_str (line 346) | def _e_x_str(self, t): # PYCHOK no cover method _isduplicate (line 354) | def _isduplicate(self): method isenclosedBy (line 375) | def isenclosedBy(self, *composites_points, **wrap): method _isinside (line 403) | def _isinside(self, composite, *excludes, **wrap): method _prev_next2 (line 426) | def _prev_next2(self): method _RPoracle (line 437) | def _RPoracle(self, p1, p2, p3): class LatLonGH (line 454) | class LatLonGH(_LatLonBool): method __init__ (line 459) | def __init__(self, lat_ll, lon=None, height=0, clipid=INT0, **wrap_name): method _check (line 471) | def _check(self): method _e_x_str (line 478) | def _e_x_str(self, t): # PYCHOK no cover method isenclosedBy (line 482) | def isenclosedBy(self, *composites_points, **wrap): method _isinside (line 506) | def _isinside(self, composite, *bottom_top, **wrap): class _Clip (line 532) | class _Clip(_Named): method __init__ (line 548) | def __init__(self, composite, clipid=INT0): method __contains__ (line 559) | def __contains__(self, point): # PYCHOK no cover method __eq__ (line 567) | def __eq__(self, other): method __ge__ (line 574) | def __ge__(self, other): method __gt__ (line 579) | def __gt__(self, other): method __hash__ (line 585) | def __hash__(self): # PYCHOK no cover method __iter__ (line 588) | def __iter__(self): method __le__ (line 598) | def __le__(self, other): method __len__ (line 603) | def __len__(self): method __lt__ (line 609) | def __lt__(self, other): method __ne__ (line 615) | def __ne__(self, other): # required for Python 2 # PYCHOK no cover method _all_ON_ON (line 623) | def _all_ON_ON(self): method _append (line 628) | def _append(self, y_v, *x_h_clipid): method _bltr4 (line 654) | def _bltr4(self): method _bltr4eps (line 658) | def _bltr4eps(self, eps): method _closed (line 669) | def _closed(self, raiser): # PYCHOK unused method _dup (line 683) | def _dup(self, q): method _edges2 (line 692) | def _edges2(self, wrap=False, **unused): method _equi (line 706) | def _equi(self, clip, eps): method _Error (line 724) | def _Error(self, txt): # PYCHOK no cover method _index (line 740) | def _index(self, clips, eps): method _insert (line 747) | def _insert(self, y, x, start, *end_alpha): method _intersection (line 767) | def _intersection(self, unused, q, *p1_p2_alpha): method _intersections (line 777) | def _intersections(self): method _ishole (line 784) | def _ishole(self): # PYCHOK no cover method _nodups (line 790) | def _nodups(self): method _noXings (line 796) | def _noXings(self, Union): method _OpenClipError (line 801) | def _OpenClipError(self, s, e): # PYCHOK no cover method _point2 (line 806) | def _point2(self, insert): method _points (line 827) | def _points(self, may_be=True): method _remove2 (line 833) | def _remove2(self, v): method _update_all (line 851) | def _update_all(self): # PYCHOK no cover method _Xings (line 857) | def _Xings(self): class _CompositeBase (line 865) | class _CompositeBase(_Named): method __init__ (line 876) | def __init__(self, lls, kind=NN, eps=EPS, **name): method __contains__ (line 904) | def __contains__(self, point): # PYCHOK no cover method __eq__ (line 912) | def __eq__(self, other): method __iter__ (line 921) | def __iter__(self): method __ne__ (line 928) | def __ne__(self, other): # required for Python 2 method __len__ (line 933) | def __len__(self): method __repr__ (line 938) | def __repr__(self): method __str__ (line 947) | def __str__(self): method _bottom_top_eps2 (line 953) | def _bottom_top_eps2(self): method _class (line 958) | def _class(self, corners, kwds, **dflts): method _clipids (line 965) | def _clipids(self): # PYCHOK no cover method clipids (line 969) | def clipids(self): method _edges3 (line 978) | def _edges3(self, **raiser_wrap): method _encloses (line 985) | def _encloses(self, lat, lon, **wrap): method eps (line 990) | def eps(self): method eps (line 996) | def eps(self, eps): method _10eps (line 1001) | def _10eps(self, **eps_): method _equi (line 1010) | def _equi(self, other, eps): method _intersections (line 1030) | def _intersections(self): method isequalTo (line 1036) | def isequalTo(self, other, eps=None): method _kwds (line 1053) | def _kwds(self, op, **more): method _left_right_eps2 (line 1061) | def _left_right_eps2(self): method _points (line 1066) | def _points(self, may_be=True): # PYCHOK no cover method raiser (line 1073) | def raiser(self): method raiser (line 1079) | def raiser(self, throw): method _results (line 1084) | def _results(self, _presults, Clas, closed=False, inull=False, **eps): method _sum (line 1107) | def _sum(self, other, op): method _sum1 (line 1120) | def _sum1(self, _a_p, *args, **kwds): # in .karney, .points method _sum2 (line 1124) | def _sum2(self, LL, _a_p, *args, **kwds): # in .sphericalNvector, -Tr... method toLatLon (line 1134) | def toLatLon(self, LatLon=None, closed=False, **LatLon_kwds): class _CompositeFHP (line 1171) | class _CompositeFHP(_CompositeBase): method __init__ (line 1179) | def __init__(self, lls, raiser=False, **name_kind_eps): method _classify (line 1185) | def _classify(self): method _clip (line 1203) | def _clip(self, corners, Union=False, Clas=None, method _identicals (line 1250) | def _identicals(self): method _labelize (line 1256) | def _labelize(self): method _presults (line 1269) | def _presults(self, other): method _resultX (line 1280) | def _resultX(self, X): method _set_entry_exits (line 1301) | def _set_entry_exits(self, other): # MCCABE 14 method _special_cases (line 1337) | def _special_cases(self, other): method _special_identicals (line 1350) | def _special_identicals(self, other): method _2splits (line 1365) | def _2splits(self): method _splits_xings (line 1372) | def _splits_xings(self, other): # MCCABE 15 method _2xings (line 1412) | def _2xings(self): class _CompositeGH (line 1419) | class _CompositeGH(_CompositeBase): method __init__ (line 1427) | def __init__(self, lls, raiser=False, xtend=False, **name_kind_eps): method _clip (line 1435) | def _clip(self, corners, s_entry, c_entry, Clas=None, method _first (line 1472) | def _first(self): method _kwds (line 1478) | def _kwds(self, op, **more): method _presults (line 1482) | def _presults(self): method _resultU (line 1489) | def _resultU(self, v): method xtend (line 1506) | def xtend(self): method xtend (line 1512) | def xtend(self, xtend): class _EdgeFHP (line 1518) | class _EdgeFHP(object): method __init__ (line 1533) | def __init__(self, p1, p2, **unused): method _intersect3 (line 1542) | def _intersect3(self, q1, q2): class _EdgeGH (line 1591) | class _EdgeGH(object): method __init__ (line 1597) | def __init__(self, s1, s2, raiser=False, xtend=False, **unused): method _alpha2 (line 1610) | def _alpha2(self, x, y, dx, dy): method _Error (line 1616) | def _Error(self, n, *args, **kwds): # PYCHOK no cover method _hypot0 (line 1622) | def _hypot0(self): method _hypot2 (line 1627) | def _hypot2(self): method _intersect4 (line 1631) | def _intersect4(self, c1, c2, parallel=True): # MCCABE 14 class _BooleanBase (line 1700) | class _BooleanBase(object): method __add__ (line 1703) | def __add__(self, other): method __and__ (line 1708) | def __and__(self, other): method __iadd__ (line 1713) | def __iadd__(self, other): method __iand__ (line 1718) | def __iand__(self, other): method __ior__ (line 1723) | def __ior__(self, other): method __or__ (line 1728) | def __or__(self, other): method __radd__ (line 1733) | def __radd__(self, other): method __rand__ (line 1738) | def __rand__(self, other): method __ror__ (line 1743) | def __ror__(self, other): method _boolean4 (line 1748) | def _boolean4(self, other, op): method _inplace (line 1756) | def _inplace(self, r): class BooleanFHP (line 1768) | class BooleanFHP(_CompositeFHP, _BooleanBase): method __init__ (line 1791) | def __init__(self, lls, raiser=False, eps=EPS, **name): method __isub__ (line 1803) | def __isub__(self, other): method __rsub__ (line 1807) | def __rsub__(self, other): method __sub__ (line 1811) | def __sub__(self, other): method _boolean (line 1815) | def _boolean(self, other, Union, unused, op): class BooleanGH (line 1822) | class BooleanGH(_CompositeGH, _BooleanBase): method __init__ (line 1851) | def __init__(self, lls, raiser=True, xtend=False, eps=EPS, **name): method _boolean (line 1865) | def _boolean(self, other, s_entry, c_entry, op): method __isub__ (line 1871) | def __isub__(self, other): method __rsub__ (line 1876) | def __rsub__(self, other): method __sub__ (line 1881) | def __sub__(self, other): function _alpha1 (line 1887) | def _alpha1(alpha): # PYCHOK no cover function _alpha4 (line 1895) | def _alpha4(a): function _Cps (line 1904) | def _Cps(Cp, composites_points, where): function _eps0 (line 1914) | def _eps0(eps): function isBoolean (line 1919) | def isBoolean(obj): function _left_right_bottom_top_eps2 (line 1930) | def _left_right_bottom_top_eps2(p1, p2): function _low_high_eps2 (line 1937) | def _low_high_eps2(lo, hi, eps): function _min_max_eps2 (line 1953) | def _min_max_eps2(*xs): function _other (line 1959) | def _other(this, other): function _outside (line 1968) | def _outside(x1, x2, lo, hi): FILE: pygeodesy/cartesianBase.py class CartesianBase (line 53) | class CartesianBase(Vector3d, _EcefLocal): method __init__ (line 59) | def __init__(self, x_xyz, y=None, z=None, datum=None, **ll_name): method cassini (line 90) | def cassini(self, pointB, pointC, alpha, beta, useZ=False): method collins (line 120) | def collins(self, pointB, pointC, alpha, beta, useZ=False): method collins5 (line 124) | def collins5(self, pointB, pointC, alpha, beta, useZ=False): method convertDatum (line 156) | def convertDatum(self, datum2, **datum): method datum (line 161) | def datum(self): method datum (line 167) | def datum(self, datum): method destinationXyz (line 184) | def destinationXyz(self, delta, Cartesian=None, **name_Cartesian_kwds): method _ecef9 (line 217) | def _ecef9(self): method ellipsoidalCartesian (line 223) | def ellipsoidalCartesian(self): method hartzell (line 228) | def hartzell(self, los=False, earth=None): method height (line 253) | def height(self): method height (line 259) | def height(self, height): method _height2C (line 271) | def _height2C(self, r, Cartesian=None, datum=None, height=INT0, **kwds): method height3 (line 282) | def height3(self, earth=None, height=None, **Cartesian_and_kwds): method _height4 (line 323) | def _height4(self): method height4 (line 332) | def height4(self, earth=None, normal=True, **Cartesian_and_kwds): method isEllipsoidal (line 380) | def isEllipsoidal(self): method isSpherical (line 386) | def isSpherical(self): method latlon (line 392) | def latlon(self): method latlonheight (line 398) | def latlonheight(self): method latlonheightdatum (line 404) | def latlonheightdatum(self): method _N_vector (line 410) | def _N_vector(self): method _n_xyzh4 (line 416) | def _n_xyzh4(self, datum, Vector=Vector4Tuple): method philam (line 465) | def philam(self): method philamheight (line 471) | def philamheight(self): method philamheightdatum (line 477) | def philamheightdatum(self): method pierlot (line 482) | def pierlot(self, point2, point3, alpha12, alpha23, useZ=False, eps=EPS): method pierlotx (line 513) | def pierlotx(self, point2, point3, alpha1, alpha2, alpha3, useZ=False): method Roc2 (line 540) | def Roc2(self, earth=None): method sphericalCartesian (line 569) | def sphericalCartesian(self): method tienstra (line 575) | def tienstra(self, pointB, pointC, alpha, beta=None, gamma=None, useZ=... method tienstra7 (line 579) | def tienstra7(self, pointB, pointC, alpha, beta=None, gamma=None, useZ... method to2ab (line 615) | def to2ab(self): # PYCHOK no cover method to2ll (line 623) | def to2ll(self): # PYCHOK no cover method to3llh (line 631) | def to3llh(self, datum=None): # PYCHOK no cover method toDatum (line 652) | def toDatum(self, datum2, datum=None): method toEcef (line 688) | def toEcef(self): method toLatLon (line 698) | def toLatLon(self, datum=None, height=None, LatLon=None, **LatLon_kwds... method toNvector (line 728) | def toNvector(self, Nvector=None, datum=None, **name_Nvector_kwds): method toRtp (line 762) | def toRtp(self): method toStr (line 772) | def toStr(self, prec=3, fmt=Fmt.SQUARE, sep=_COMMASPACE_): # PYCHOK e... method toTransform (line 783) | def toTransform(self, transform, inverse=False, datum=None): method toVector (line 807) | def toVector(self, Vector=None, **Vector_kwds): class RadiusThetaPhi3Tuple (line 824) | class RadiusThetaPhi3Tuple(_NamedTupleTo): method toCartesian (line 833) | def toCartesian(self, **name_Cartesian_and_kwds): method toDegrees (line 850) | def toDegrees(self, **name): method toRadians (line 860) | def toRadians(self, **name): method _toU (line 870) | def _toU(self, U): method _toX3U (line 874) | def _toX3U(self, _X3, U, name): function rtp2xyz (line 883) | def rtp2xyz(r_rtp, theta=0, phi=0, **name_Cartesian_and_kwds): function rtp2xyz_ (line 899) | def rtp2xyz_(r_rtp, theta=0, phi=0, **name_Cartesian_and_kwds): function _rtp3 (line 944) | def _rtp3(where, U, *x_y_z, **name): function xyz2rtp (line 962) | def xyz2rtp(x_xyz, y=0, z=0, **name): function xyz2rtp_ (line 973) | def xyz2rtp_(x_xyz, y=0, z=0, **name): FILE: pygeodesy/clipy.py function _box4 (line 40) | def _box4(lowerleft, upperight, name): function _4corners (line 55) | def _4corners(corners): function _eq (line 66) | def _eq(p1, p2, eps=EPS): function _neq (line 72) | def _neq(p1, p2, eps=EPS): function _pts2 (line 79) | def _pts2(points, closed, inull): class _CS (line 95) | class _CS(_Named): method __init__ (line 115) | def __init__(self, lowerleft, upperight, name=__name__): method code4 (line 132) | def code4(self, p): # compute code for point p method edge (line 147) | def edge(self, p1, p2): # set edge p1 to p2 method lat4 (line 152) | def lat4(self, x, p): # new lat and code at lon x method lon4 (line 161) | def lon4(self, y, p): # new lon and code at lat y method nop4 (line 170) | def nop4(self, b, p): # PYCHOK no cover class ClipCS4Tuple (line 176) | class ClipCS4Tuple(_NamedTuple): function clipCS4 (line 187) | def clipCS4(points, lowerleft, upperight, closed=False, inull=False): class ClipFHP4Tuple (line 239) | class ClipFHP4Tuple(_NamedTuple): method isintersection (line 250) | def isintersection(self): method ispoint (line 256) | def ispoint(self): function clipFHP4 (line 262) | def clipFHP4(points, corners, closed=False, inull=False, raiser=False, e... class ClipGH4Tuple (line 292) | class ClipGH4Tuple(ClipFHP4Tuple): function clipGH4 (line 303) | def clipGH4(points, corners, closed=False, inull=False, raiser=True, xte... function _LBtrim (line 338) | def _LBtrim(p, q, t): class ClipLB6Tuple (line 357) | class ClipLB6Tuple(_NamedTuple): function clipLB6 (line 372) | def clipLB6(points, lowerleft, upperight, closed=False, inull=False): class _SH (line 451) | class _SH(_Named): method __init__ (line 464) | def __init__(self, corners, name=__name__): method clip2 (line 482) | def clip2(self, points, closed, inull): # MCCABE 13, clip points method clipedges (line 531) | def clipedges(self): # yield clip edge index method clipped2 (line 547) | def clipped2(self, p): # return (clipped point [i], edge) method dot2 (line 553) | def dot2(self, p): # dot product of point p to clip method intersect (line 564) | def intersect(self, p1, p2, edge): # compute intersection class _SHlist (line 583) | class _SHlist(list): method __init__ (line 588) | def __init__(self, inull): method append (line 592) | def append(self, p): class _SHlli (line 597) | class _SHlli(LatLon_): method __init__ (line 604) | def __init__(self, lat, lon, classof, edge): class ClipSH3Tuple (line 612) | class ClipSH3Tuple(_NamedTuple): function clipSH (line 623) | def clipSH(points, corners, closed=False, inull=False): function clipSH3 (line 649) | def clipSH3(points, corners, closed=False, inull=False): FILE: pygeodesy/constants.py function _copysign_0_0 (line 32) | def _copysign_0_0(y): function _copysign_1_0 (line 38) | def _copysign_1_0(y): function _copysignINF (line 44) | def _copysignINF(y): function _flipsign (line 50) | def _flipsign(x, y=-1): function _Float (line 56) | def _Float(**name_arg): function _float (line 63) | def _float(x): # in .datums, .ellipsoids, ... function float_ (line 70) | def float_(x, sets=False): function float0_ (line 93) | def float0_(*xs): function _float0 (line 100) | def _float0(x): # in .auxilats.auxily, .resections, .vector3dBase, ... function floats_ (line 113) | def floats_(*xs, **sets): # sets=False function _floatuple (line 135) | def _floatuple(*fs): function _log2 (line 146) | def _log2(x): # in .rhumb.aux_, .auxilats.auxLat function _naninf (line 150) | def _naninf(p, *xs): function _over (line 158) | def _over(p, q): function _over_1 (line 167) | def _over_1(p, q): function _1_over (line 179) | def _1_over(x): function _Radius (line 188) | def _Radius(**name_arg): function _0_0s (line 344) | def _0_0s(n): function _isclose (line 354) | def _isclose(a, b, rel_tol=1e-9, abs_tol=0): function isclose (line 364) | def isclose(a, b, rel_tol=1e-12, abs_tol=EPS0): function _iscfinite (line 375) | def _iscfinite(x): # PYCHOK not self? function _isfinite (line 384) | def _isfinite(x): # PYCHOK not self? function isfinite (line 390) | def isfinite(obj): function isint0 (line 411) | def isint0(obj, both=False): function isnear0 (line 425) | def isnear0(x, eps0=EPS0): function isnear1 (line 439) | def isnear1(x, eps1=EPS0): function isnear90 (line 452) | def isnear90(x, eps90=EPS0): function isneg (line 465) | def isneg(x): function isneg0 (line 476) | def isneg0(x): function isninf (line 488) | def isninf(x): function isnon0 (line 499) | def isnon0(x, eps0=EPS0): function _off90 (line 513) | def _off90(lat): function remainder (line 524) | def remainder(x, y): function _umod_360 (line 540) | def _umod_360(deg): function _umod_PI2 (line 546) | def _umod_PI2(rad): function _main (line 554) | def _main(globalocals): FILE: pygeodesy/css.py function _CS0 (line 40) | def _CS0(cs0): class CSSError (line 52) | class CSSError(_ValueError): class CassiniSoldner (line 58) | class CassiniSoldner(_NamedBase): method __init__ (line 69) | def __init__(self, lat0, lon0, datum=_WGS84, **name): method datum (line 88) | def datum(self): method datum (line 94) | def datum(self, datum): method _datumatch (line 104) | def _datumatch(self, latlon): method equatoradius (line 114) | def equatoradius(self): method flattening (line 122) | def flattening(self): method forward (line 129) | def forward(self, lat, lon, **name): method forward4 (line 148) | def forward4(self, lat, lon, **name): method forward6 (line 169) | def forward6(self, lat, lon, **name): method geodesic (line 219) | def geodesic(self): method geodesic (line 237) | def geodesic(self, exact): method isExact (line 251) | def isExact(self): method lat0 (line 258) | def lat0(self): method latlon0 (line 264) | def latlon0(self): method latlon0 (line 271) | def latlon0(self, latlon0): method lon0 (line 290) | def lon0(self): method majoradius (line 296) | def majoradius(self): # PYCHOK no cover method reset (line 300) | def reset(self, lat0, lon0): method reverse (line 318) | def reverse(self, easting, northing, LatLon=None, **name_LatLon_kwds): method reverse4 (line 350) | def reverse4(self, easting, northing, **name): method toRepr (line 375) | def toRepr(self, prec=6, **unused): # PYCHOK expected method toStr (line 385) | def toStr(self, prec=6, sep=_SPACE_, **unused): # PYCHOK expected class Css (line 397) | class Css(_NamedBase): method __init__ (line 406) | def __init__(self, e, n, h=0, cs0=None, **name): method azi (line 433) | def azi(self): method cs0 (line 441) | def cs0(self): method cs0 (line 447) | def cs0(self, cs0): method easting (line 476) | def easting(self): method height (line 482) | def height(self): method latlon (line 488) | def latlon(self): method northing (line 495) | def northing(self): method reverse4 (line 501) | def reverse4(self): method rk (line 507) | def rk(self): method toLatLon (line 514) | def toLatLon(self, LatLon=None, height=None, **LatLon_kwds): method toRepr (line 539) | def toRepr(self, prec=6, fmt=Fmt.SQUARE, sep=_COMMASPACE_, m=_m_, C=Fa... method toStr (line 560) | def toStr(self, prec=6, sep=_SPACE_, m=_m_): # PYCHOK expected class EasNorAziRk4Tuple (line 576) | class EasNorAziRk4Tuple(_NamedTuple): class EasNorAziRkEqu6Tuple (line 586) | class EasNorAziRkEqu6Tuple(_NamedTuple): class LatLonAziRk4Tuple (line 597) | class LatLonAziRk4Tuple(_NamedTuple): function toCss (line 606) | def toCss(latlon, cs0=None, height=None, Css=Css, **name): FILE: pygeodesy/datums.py class Transform (line 120) | class Transform(_NamedEnumItem): method __init__ (line 140) | def __init__(self, name=NN, tx=0, ty=0, tz=0, method __eq__ (line 173) | def __eq__(self, other): method __hash__ (line 183) | def __hash__(self): method __iter__ (line 186) | def __iter__(self): method __matmul__ (line 192) | def __matmul__(self, point): # PYCHOK Python 3.5+ method __neg__ (line 204) | def __neg__(self): method inverse (line 207) | def inverse(self, **name): method isunity (line 221) | def isunity(self): method items (line 227) | def items(self, inverse=False): method _rps2 (line 236) | def _rps2(self, s_): method _s_s1 (line 243) | def _s_s1(self, s1): # in .trf method toStr (line 251) | def toStr(self, prec=5, fmt=Fmt.g, **sep_name): # PYCHOK expected method transform (line 264) | def transform(self, x, y, z, inverse=False, **Vector_and_kwds): class Transforms (line 300) | class Transforms(_NamedEnum): method _Lazy (line 304) | def _Lazy(self, **name_tx_ty_tz_s_sx_sy_sz): class Datum (line 376) | class Datum(_NamedEnumItem): method __init__ (line 382) | def __init__(self, ellipsoid, transform=None, **name): method __eq__ (line 404) | def __eq__(self, other): method __hash__ (line 415) | def __hash__(self): method __matmul__ (line 418) | def __matmul__(self, point): # PYCHOK Python 3.5+ method ecef (line 426) | def ecef(self, Ecef=None): method ellipsoid (line 440) | def ellipsoid(self): method exactTM (line 446) | def exactTM(self): method _hash (line 452) | def _hash(self): method isEllipsoidal (line 456) | def isEllipsoidal(self): method isOblate (line 462) | def isOblate(self): method isProlate (line 468) | def isProlate(self): method isSpherical (line 474) | def isSpherical(self): method toStr (line 479) | def toStr(self, sep=_COMMASPACE_, **name): # PYCHOK expected method transform (line 497) | def transform(self): function _earth_datum (line 503) | def _earth_datum(inst, a_earth, f=None, raiser=_a_ellipsoid_, **name): ... function _earth_ellipsoid (line 526) | def _earth_ellipsoid(earth, **name_raiser): function _ED2 (line 534) | def _ED2(radius, name): function _ellipsoidal_datum (line 546) | def _ellipsoidal_datum(earth, Error=TypeError, raiser=NN, **name): function _EnD3 (line 566) | def _EnD3(earth, name): function _equall (line 593) | def _equall(t1, t2): # in .trf function _mean_radius (line 599) | def _mean_radius(radius, *lats): function _negastr (line 613) | def _negastr(name): # in .trf, test/testTrf function _spherical_datum (line 626) | def _spherical_datum(earth, Error=TypeError, raiser=NN, **name): class Datums (line 643) | class Datums(_NamedEnum): method _Lazy (line 647) | def _Lazy(self, ellipsoid_name, transform_name, **name): FILE: pygeodesy/deprecated/bases.py class LatLonHeightBase (line 15) | class LatLonHeightBase(_LatLonBase): # PYCHOK no cover FILE: pygeodesy/deprecated/classes.py class _Deprecated_NamedTuple (line 29) | class _Deprecated_NamedTuple(_NamedTuple): method __new__ (line 32) | def __new__(cls, *args, **kwds): function _reNames (line 37) | def _reNames(names, old, *new): class ClipCS3Tuple (line 43) | class ClipCS3Tuple(_Deprecated_NamedTuple): # PYCHOK no cover class ConformalTriaxial (line 50) | class ConformalTriaxial(Conformal): method __init__ (line 52) | def __init__(self, *args, **kwds): # PYCHOK no cover class EasNorExact4Tuple (line 57) | class EasNorExact4Tuple(_Deprecated_NamedTuple): function EcefCartesian (line 63) | def EcefCartesian(*args, **kwds): function Fn_rt (line 109) | def Fn_rt(root, *xs, **name_RESIDUAL_raiser): # PYCHOK no cover function FrechetCosineAndoyerLambert (line 122) | def FrechetCosineAndoyerLambert(point1s, **kwds): # PYCHOK no cover function FrechetCosineForsytheAndoyerLambert (line 136) | def FrechetCosineForsytheAndoyerLambert(point1s, **kwds): # PYCHOK no c... function HausdorffCosineAndoyerLambert (line 150) | def HausdorffCosineAndoyerLambert(point1s, **kwds): # PYCHOK no cover function HausdorffCosineForsytheAndoyerLambert (line 164) | def HausdorffCosineForsytheAndoyerLambert(point1s, **kwds): # PYCHOK no... function HeightIDW (line 178) | def HeightIDW(knots, **kwds): # PYCHOK no cover function HeightIDW2 (line 191) | def HeightIDW2(knots, **kwds): # PYCHOK no cover function HeightIDW3 (line 204) | def HeightIDW3(knots, **kwds): # PYCHOK no cover function HeightIDWcosineAndoyerLambert (line 218) | def HeightIDWcosineAndoyerLambert(knots, **kwds): # PYCHOK no cover function HeightIDWcosineForsytheAndoyerLambert (line 232) | def HeightIDWcosineForsytheAndoyerLambert(knots, **kwds): # PYCHOK no c... class JacobiConformal (line 246) | class JacobiConformal(Conformal): method __init__ (line 248) | def __init__(self, *args, **kwds): # PYCHOK no cover class JacobiConformalSpherical (line 253) | class JacobiConformalSpherical(ConformalSphere): method __init__ (line 255) | def __init__(self, *args, **kwds): # PYCHOK no cover class Jacobi2Tuple (line 260) | class Jacobi2Tuple(Conformal2Tuple): method __new__ (line 263) | def __new__(cls, *args, **kwds): class Lam_ (line 268) | class Lam_(Lamd): method __init__ (line 270) | def __init__(self, *args, **kwds): # PYCHOK no cover class LatLonExact4Tuple (line 275) | class LatLonExact4Tuple(_Deprecated_NamedTuple): class NearestOn4Tuple (line 281) | class NearestOn4Tuple(_Deprecated_NamedTuple): # PYCHOK no cover class Phi_ (line 287) | class Phi_(Phid): method __init__ (line 289) | def __init__(self, *args, **kwds): # PYCHOK no cover class Ned3Tuple (line 294) | class Ned3Tuple(_Deprecated_NamedTuple): # was in .ellipsoidalNvector function RefFrameError (line 301) | def RefFrameError(*args, **kwds): # PYCHOK no cover class Rhumb7Tuple (line 315) | class Rhumb7Tuple(_Deprecated_NamedTuple): method toDirect9Tuple (line 322) | def toDirect9Tuple(self, **kwds): # PYCHOK no cover method toGDict (line 326) | def toGDict(self, **kwds): # PYCHOK no cover method toInverse10Tuple (line 330) | def toInverse10Tuple(self, **kwds): # PYCHOK no cover method toRhumb8Tuple (line 334) | def toRhumb8Tuple(self, dflt=NAN): # PYCHOK no cover method _to7Tuple (line 337) | def _to7Tuple(self): # PYCHOK no cover class RhumbOrder2Tuple (line 343) | class RhumbOrder2Tuple(_Deprecated_NamedTuple, _GTuple): class Transform7Tuple (line 351) | class Transform7Tuple(_Deprecated_NamedTuple): # PYCHOK no cover method __new__ (line 356) | def __new__(cls, tx=0, ty=0, tz=0, s=0, class TriAngle4Tuple (line 364) | class TriAngle4Tuple(_Deprecated_NamedTuple): class UtmUps4Tuple (line 371) | class UtmUps4Tuple(_Deprecated_NamedTuple): # PYCHOK no cover class XDist (line 381) | class XDist(ADict): method __init__ (line 383) | def __init__(self, *args, **kwds): # PYCHOK no cover FILE: pygeodesy/deprecated/consterns.py class _Deprecated_Float (line 17) | class _Deprecated_Float(Float): class _Deprecated_Int (line 22) | class _Deprecated_Int(Int): class _Deprecated_Str (line 27) | class _Deprecated_Str(Str): class Elliperim (line 32) | class Elliperim(object): method AGM (line 36) | def AGM(self, a, b, **unused): # PYCHOK no cover method Arc43 (line 41) | def Arc43(self, a, b): # PYCHOK no cover method E2k (line 46) | def E2k(self, a, b): # PYCHOK no cover method e2k (line 51) | def e2k(self, a, b, **unused): # PYCHOK no cover method GK (line 56) | def GK(self, a, b): # PYCHOK no cover method HG (line 61) | def HG(self, a, b, **unused): # PYCHOK no cover method R2 (line 66) | def R2(self, a, b): # PYCHOK no cover FILE: pygeodesy/deprecated/functions.py function anStr (line 25) | def anStr(name, OKd='._-', sub=_UNDER_): # PYCHOK no cover function areaof (line 31) | def areaof(points, adjust=True, radius=R_M, wrap=True): # PYCHOK no cover function atand (line 37) | def atand(x): # PYCHOK no cover function bounds (line 43) | def bounds(points, wrap=True, LatLon=None): # PYCHOK no cover function clipCS3 (line 53) | def clipCS3(points, lowerleft, upperright, closed=False, inull=False): ... function clipDMS (line 65) | def clipDMS(deg, limit): # PYCHOK no cover function clipStr (line 71) | def clipStr(bstr, limit=50, white=NN): # PYCHOK no cover function collins (line 77) | def collins(pointA, pointB, pointC, alpha, beta, **useZ_Clas_and_kwds): function copysign (line 84) | def copysign(x, y): # PYCHOK no cover function cosineAndoyerLambert (line 90) | def cosineAndoyerLambert(lat1, lon1, lat2, lon2, **datum_wrap): function cosineAndoyerLambert_ (line 96) | def cosineAndoyerLambert_(phi2, phi1, lam21, **datum): function cosineForsytheAndoyerLambert (line 102) | def cosineForsytheAndoyerLambert(lat1, lon1, lat2, lon2, **datum_wrap): function cosineForsytheAndoyerLambert_ (line 108) | def cosineForsytheAndoyerLambert_(phi2, phi1, lam21, **datum): function decodeEPSG2 (line 114) | def decodeEPSG2(arg): # PYCHOK no cover function elliperim (line 123) | def elliperim(a, b, *deg2_1): # PYCHOK no cover function elliperim_ (line 130) | def elliperim_(a, b, *rad2_1): # PYCHOK no cover function encodeEPSG (line 137) | def encodeEPSG(zone, hemipole=NN, band=NN): # PYCHOK no cover function enStr2 (line 146) | def enStr2(easting, northing, prec, *extras): # PYCHOK no cover function equirectangular_ (line 152) | def equirectangular_(lat1, lon1, lat2, lon2, **options): # PYCHOK no cover function equirectangular3 (line 158) | def equirectangular3(lat1, lon1, lat2, lon2, **options): # PYCHOK no cover function excessAbc (line 167) | def excessAbc(A, b, c): # PYCHOK no cover function excessGirard (line 173) | def excessGirard(A, B, C): # PYCHOK no cover function excessLHuilier (line 179) | def excessLHuilier(a, b, c): # PYCHOK no cover function false2f (line 185) | def false2f(value, name=_value_, false=True, Error=ValueError): # PYCHO... function falsed2f (line 191) | def falsed2f(falsed=True, Error=ValueError, **name_value): # PYCHOK no ... function float0 (line 219) | def float0(*xs): # PYCHOK no cover function fStr (line 225) | def fStr(floats, prec=6, fmt=_MODS.streprs.Fmt.f, ints=False, sep=_COMMA... function fStrzs (line 231) | def fStrzs(floatstr): # PYCHOK no cover function Fsum2product (line 237) | def Fsum2product(*xs, **kwds): function hypot3 (line 245) | def hypot3(x, y, z): # PYCHOK no cover function inStr (line 251) | def inStr(inst, *args, **kwds): # PYCHOK no cover function isenclosedby (line 257) | def isenclosedby(point, points, wrap=False): # PYCHOK no cover function istuplist (line 263) | def istuplist(obj, minum=0): # PYCHOK no cover function joined (line 269) | def joined(*words, **sep): # PYCHOK no cover function joined_ (line 275) | def joined_(*words, **sep): # PYCHOK no cover function nearestOn3 (line 281) | def nearestOn3(point, points, closed=False, wrap=False, **options): # P... function nearestOn4 (line 290) | def nearestOn4(point, points, closed=False, wrap=False, **options): # P... function parseUTM (line 299) | def parseUTM(strUTM, datum=_WGS84, Utm=_UTM, name=NN): # PYCHOK no cover function perimeterof (line 314) | def perimeterof(points, closed=False, adjust=True, radius=R_M, wrap=True... function polygon (line 320) | def polygon(points, closed=True, base=None): # PYCHOK no cover function scalar (line 326) | def scalar(value, low=EPS, high=1.0, name=_scalar_, Error=ValueError): ... function simplify2 (line 338) | def simplify2(points, pipe=_1mm, **radius_shortest_indices_options): # ... function simplifyRDPm (line 344) | def simplifyRDPm(points, distance=_1mm, **radius_shortest_indices_options): function simplifyVWm (line 350) | def simplifyVWm(points, area=_1mm, **radius_attr_indices_options): function tienstra (line 356) | def tienstra(pointA, pointB, pointC, alpha, **beta_gamma_useZ_Clas_and_k... function toUtm (line 362) | def toUtm(latlon, lon=None, datum=None, Utm=_UTM, cmoff=True, name=NN): ... function triAngle4 (line 387) | def triAngle4(a, b, c): function unsign0 (line 397) | def unsign0(x): # PYCHOK no cover function unStr (line 403) | def unStr(name, *args, **kwds): # PYCHOK no cover function utmZoneBand2 (line 409) | def utmZoneBand2(lat, lon): # PYCHOK no cover FILE: pygeodesy/deprecated/nvector.py class Nvector (line 17) | class Nvector(NvectorBase): # PYCHOK no cover method __init__ (line 20) | def __init__(self, x, y=None, z=None, h=0, ll=None, datum=None, name=NN): FILE: pygeodesy/dms.py function _D603 (line 133) | def _D603(sep, s_D=_DOT_, s_M=None, s_S=S_NUL, s_DMS=S_DMS, **unused): function _DMS3 (line 143) | def _DMS3(form, s_D=S_DEG, s_M=S_MIN, s_S=S_SEC, s_DMS=S_DMS, **unused): function _dms3 (line 149) | def _dms3(d, ddd, p, w): function _DR2 (line 160) | def _DR2(s_D=S_NUL, s_R=S_RAD, **unused): function _fstrzs (line 166) | def _fstrzs(t, **unused): function _split3 (line 172) | def _split3(strDMS, suffix=_NSEW_): function _toDMS (line 182) | def _toDMS(deg, form, prec, sep, ddd, P, s_D_M_S): # MCCABE 15 in .units function bearingDMS (line 254) | def bearingDMS(bearing, form=F_D, prec=None, sep=S_SEP, **s_D_M_S): function _clip (line 271) | def _clip(angle, limit, units): function clipDegrees (line 282) | def clipDegrees(deg, limit): function clipRadians (line 296) | def clipRadians(rad, limit): function compassDMS (line 310) | def compassDMS(bearing, form=F_D, prec=None, sep=S_SEP, **s_D_M_S): function compassPoint (line 328) | def compassPoint(bearing, prec=3): function degDMS (line 360) | def degDMS(deg, prec=6, s_D=S_DEG, s_M=S_MIN, s_S=S_SEC, neg=_MINUS_, po... function latDMS (line 403) | def latDMS(deg, form=_F_DMS, prec=None, sep=S_SEP, **s_D_M_S): function latlonDMS (line 421) | def latlonDMS(lls, **m_form_prec_sep_s_D_M_S): function latlonDMS_ (line 451) | def latlonDMS_(*lls, **m_form_prec_sep_s_D_M_S): function _latlonDMS_sep2 (line 480) | def _latlonDMS_sep2(where, sep=None, **kwds): function lonDMS (line 492) | def lonDMS(deg, form=_F_DMS, prec=None, sep=S_SEP, **s_D_M_S): function normDMS (line 510) | def normDMS(strDMS, norm=None, **s_D_M_S): function parseDDDMMSS (line 549) | def parseDDDMMSS(strDDDMMSS, suffix=_NSEW_, sep=S_SEP, clip=0, sexagecim... function _DDDMMSS5 (line 631) | def _DDDMMSS5(f, S, sexagecimal): function _DDDMMSS6 (line 657) | def _DDDMMSS6(t, S): function _DMS2deg (line 681) | def _DMS2deg(strDMS, suffix, sep, clip, s_D_M_S): function _dms2deg (line 698) | def _dms2deg(n, P, d, m=_0_0, s=_0_0): function parseDMS (line 708) | def parseDMS(strDMS, suffix=_NSEW_, sep=S_SEP, clip=0, **s_D_M_S): # MC... function parseDMS2 (line 746) | def parseDMS2(strLat, strLon, sep=S_SEP, clipLat=90, clipLon=180, wrap=F... function _2Tuple (line 776) | def _2Tuple(strLat, strLon, clipLat, clipLon, wrap, **kwds): function parse3llh (line 791) | def parse3llh(strllh, height=0, sep=_COMMA_, clipLat=90, clipLon=180, wr... function parseRad (line 845) | def parseRad(strRad, suffix=_NSEW_, clip=0): function precision (line 870) | def precision(form, prec=None): function toDMS (line 894) | def toDMS(deg, form=_F_DMS, prec=2, sep=S_SEP, ddd=2, neg=_MINUS_, pos=_... FILE: pygeodesy/ecef.py class EcefError (line 102) | class EcefError(_ValueError): class _EcefBase (line 108) | class _EcefBase(_NamedBase): method __init__ (line 116) | def __init__(self, a_ellipsoid=_EWGS84, f=None, lon00=INT0, **name): method __eq__ (line 160) | def __eq__(self, other): method datum (line 171) | def datum(self): method ellipsoid (line 177) | def ellipsoid(self): method equatoradius (line 183) | def equatoradius(self): method flattening (line 191) | def flattening(self): # Karney property method _forward (line 199) | def _forward(self, lat, lon, h, name, M=False, _philam=False): # in .... method forward (line 221) | def forward(self, latlonh, lon=None, height=0, M=False, **name): method forward_ (line 248) | def forward_(self, phi, lam, height=0, M=False, **name): method _Geocentrics (line 272) | def _Geocentrics(self): method lon00 (line 279) | def lon00(self): method lon00 (line 285) | def lon00(self, lon00): method _Matrix (line 290) | def _Matrix(self, sa, ca, sb, cb): method _polon (line 302) | def _polon(self, y, x, p, **lon00_name): method reverse (line 307) | def reverse(self, xyz, y=None, z=None, M=False, **tol_lon00_name): # ... method toStr (line 311) | def toStr(self, prec=9, **unused): # PYCHOK signature method _xyzllhCpn9 (line 320) | def _xyzllhCpn9(self, xyz, y, z, **lon00_name): class EcefFarrell21 (line 348) | class EcefFarrell21(_EcefBase): method reverse (line 354) | def reverse(self, xyz, y=None, z=None, M=None, **lon00_name): # PYCHO... class EcefFarrell22 (line 421) | class EcefFarrell22(_EcefBase): method reverse (line 427) | def reverse(self, xyz, y=None, z=None, M=None, **lon00_name): # PYCHO... class EcefKarney (line 466) | class EcefKarney(_EcefBase): method reverse (line 479) | def reverse(self, xyz, y=None, z=None, M=False, **lon00_name): class EcefSudano (line 601) | class EcefSudano(_EcefBase): method reverse (line 607) | def reverse(self, xyz, y=None, z=None, M=None, tol=EPS, **lon00_name):... method tolerance (line 675) | def tolerance(self): method tolerance (line 680) | def tolerance(self, tol): class EcefUPC (line 684) | class EcefUPC(_EcefBase): method reverse (line 689) | def reverse(self, xyz, y=None, z=None, M=None, tol=EPS, **lon00_name):... class EcefVeness (line 741) | class EcefVeness(_EcefBase): method reverse (line 751) | def reverse(self, xyz, y=None, z=None, M=None, **lon00_name): # PYCHO... class EcefYou (line 804) | class EcefYou(_EcefBase): method __init__ (line 816) | def __init__(self, a_ellipsoid=_EWGS84, f=None, **lon00_name): # PYCH... method reverse (line 825) | def reverse(self, xyz, y=None, z=None, M=None, **lon00_name): # PYCHO... class EcefMatrix (line 880) | class EcefMatrix(_NamedTuple): method _validate (line 892) | def _validate(self, **unused): # PYCHOK unused method __new__ (line 897) | def __new__(cls, sa, ca, sb, cb, *_more, **name): method column (line 935) | def column(self, column): method copy (line 942) | def copy(self, **unused): # PYCHOK signature method matrix3 (line 952) | def matrix3(self): method matrixTransposed3 (line 958) | def matrixTransposed3(self): method multiply (line 963) | def multiply(self, other): method rotate (line 980) | def rotate(self, xyz, *xyz0): method row (line 1002) | def row(self, row): method unrotate (line 1010) | def unrotate(self, xyz, *xyz0): class Ecef9Tuple (line 1040) | class Ecef9Tuple(_NamedTuple, _EcefLocal): method _CartesianBase (line 1052) | def _CartesianBase(self): method convertDatum (line 1058) | def convertDatum(self, datum2): # for backward compatibility method _ecef9 (line 1063) | def _ecef9(self): # in ._EcefLocal._Ltp_ecef2local method ellipsoid (line 1067) | def ellipsoid(self): method lam (line 1073) | def lam(self): method lamVermeille (line 1079) | def lamVermeille(self): method latlon (line 1098) | def latlon(self): method latlonheight (line 1104) | def latlonheight(self): method latlonheightdatum (line 1110) | def latlonheightdatum(self): method latlonVermeille (line 1116) | def latlonVermeille(self): method lonVermeille (line 1124) | def lonVermeille(self): method Mx (line 1133) | def Mx(self): method phi (line 1140) | def phi(self): method philam (line 1146) | def philam(self): method philamheight (line 1152) | def philamheight(self): method philamheightdatum (line 1158) | def philamheightdatum(self): method philamVermeille (line 1164) | def philamVermeille(self): method toCartesian (line 1173) | def toCartesian(self, Cartesian=None, **Cartesian_kwds): method toDatum (line 1198) | def toDatum(self, datum2, **name): method toLatLon (line 1218) | def toLatLon(self, LatLon=None, **LatLon_kwds): method toVector (line 1247) | def toVector(self, Vector=None, **Vector_kwds): method xyz (line 1270) | def xyz(self): method xyzh (line 1276) | def xyzh(self): function _4Ecef (line 1282) | def _4Ecef(this, Ecef): # in .datums.Datum.ecef, .ellipsoids.Ellipsoid.... function _llhn4 (line 1292) | def _llhn4(latlonh, lon, height, suffix=NN, Error=EcefError, **name): #... function _norm3 (line 1311) | def _norm3(y, x): function _norm7 (line 1318) | def _norm7(y, x, z=0, E=_EWGS84): function _xEcef (line 1337) | def _xEcef(Ecef): # PYCHOK .latlonBase function _xyzn4 (line 1346) | def _xyzn4(xyz, y, z, Types, Error=EcefError, lon00=0, # PYCHOK unused FILE: pygeodesy/ecefLocals.py class _EcefLocal (line 25) | class _EcefLocal(_Named): method Ecef (line 31) | def Ecef(self): method _ecef9 (line 37) | def _ecef9(self): method _ecef9datum (line 42) | def _ecef9datum(self): method _ltp (line 50) | def _ltp(self): method _ltp_ecef2local (line 55) | def _ltp_ecef2local(self, ltp, Xyz_kwds, _None=None, **Xyz): # in C{E... method toAer (line 66) | def toAer(self, ltp=None, **Aer_and_kwds): method toEnu (line 82) | def toEnu(self, ltp=None, **Enu_and_kwds): method toLocal (line 98) | def toLocal(self, Xyz=None, ltp=None, **Xyz_kwds): method toLtp (line 115) | def toLtp(self, Ecef=None, **name): method toNed (line 131) | def toNed(self, ltp=None, **Ned_and_kwds): method toXyz (line 147) | def toXyz(self, ltp=None, **Xyz_and_kwds): FILE: pygeodesy/elevations.py function _json (line 60) | def _json(ngs): function _error (line 92) | def _error(fun, lat, lon, e): function _qURL (line 98) | def _qURL(url, timeout=2, **params): function _xml (line 117) | def _xml(tag, xml): class Elevation2Tuple (line 137) | class Elevation2Tuple(_NamedTuple): # .elevations.py function elevation2 (line 144) | def elevation2(lat, lon, timeout=2.0): class GeoidHeight2Tuple (line 191) | class GeoidHeight2Tuple(_NamedTuple): # .elevations.py function geoidHeight2 (line 199) | def geoidHeight2(lat, lon, model=0, timeout=2.0): FILE: pygeodesy/ellipses.py class Ellipse (line 39) | class Ellipse(_NamedBase): method __init__ (line 49) | def __init__(self, a, b, **name): method a (line 84) | def a(self): method apses2 (line 91) | def apses2(self): method arc (line 102) | def arc(self, deg2, deg1=0): method arc_ (line 113) | def arc_(self, rad2, rad1=0): method area (line 136) | def area(self): method b (line 143) | def b(self): method c (line 150) | def c(self): method e (line 157) | def e(self): method e2 (line 164) | def e2(self): method _Ek (line 173) | def _Ek(self): method _ellipE (line 178) | def _ellipE(self, k, phi=None): # PYCHOK k method _ellipe (line 185) | def _ellipe(self): method _Error (line 199) | def _Error(self, where, **cause): # PYCHOK no cover method foci (line 210) | def foci(self): method _GKs (line 224) | def _GKs(self): method hartzell4 (line 231) | def hartzell4(self, x, y, los=False): method height4 (line 258) | def height4(self, x, y, **normal_eps): method _HGKs (line 281) | def _HGKs(self, h, maxit): method isCircular (line 298) | def isCircular(self): method isFlat (line 304) | def isFlat(self): method isOblate (line 310) | def isOblate(self): method isProlate (line 316) | def isProlate(self): method lati (line 322) | def lati(self): method normal3d (line 335) | def normal3d(self, deg_x, y=None, **length): method normal4 (line 352) | def normal4(self, deg_x, y=None, **height_normal): method p (line 374) | def p(self): method perimeterAGM (line 381) | def perimeterAGM(self): method perimeter4Arc3 (line 407) | def perimeter4Arc3(self): method perimeterCR (line 444) | def perimeterCR(self): method perimeterGK (line 458) | def perimeterGK(self): method perimeterHGK (line 469) | def perimeterHGK(self): method perimeter2k (line 494) | def perimeter2k(self): method perimeter2k_ (line 501) | def perimeter2k_(self): method _perimeter2k (line 509) | def _perimeter2k(self, _ellip): method perimeter2R (line 531) | def perimeter2R(self): method perimeter2RC (line 542) | def perimeter2RC(self): method _Ph2 (line 565) | def _Ph2(self): method point (line 578) | def point(self, deg_x, y=None): method points (line 587) | def points(self, np, nq=4, ccw=False, ended=False, eps=EPS): # MCCABE 13 method polar2d (line 636) | def polar2d(self, deg_x, y=None): method R1 (line 648) | def R1(self): method R2 (line 657) | def R2(self): method Roc (line 665) | def Roc(self, deg_x, y=None, eps=None): method Roc_ (line 674) | def Roc_(self, rad_x, y=None, eps=None): method Rrectifying (line 696) | def Rrectifying(self): method _sc2 (line 701) | def _sc2(self, x, y, eps=EPS): method _sideOf (line 713) | def _sideOf(self, x, y, eps): method sideOf (line 725) | def sideOf(self, x, y, eps=EPS): method slope (line 734) | def slope(self, deg_x, y=None, eps=None): method slope_ (line 745) | def slope_(self, rad_x, y=None, eps=None): method toEllipsoid (line 762) | def toEllipsoid(self, **Ellipsoid_and_kwds): method toStr (line 773) | def toStr(self, prec=8, terse=2, **sep_name): # PYCHOK signature method toTriaxial_ (line 793) | def toTriaxial_(self, c=EPS, **Triaxial_and_kwds): # like .Ellipse5Tu... method _triaxialX (line 803) | def _triaxialX(self, method, *args, **kwds): method _xy03 (line 815) | def _xy03(self, deg_x, y): class EllipseError (line 826) | class EllipseError(_ValueError): function _arc (line 832) | def _arc(_e, k, r): function _isFlat (line 842) | def _isFlat(a, b): # in .triaxials.bases function _q1ps (line 847) | def _q1ps(a, b, n, eps): function _2RC (line 875) | def _2RC(h, r): FILE: pygeodesy/ellipsoidalBase.py class CartesianEllipsoidalBase (line 52) | class CartesianEllipsoidalBase(CartesianBase): method __init__ (line 59) | def __init__(self, x_xyz, y=None, z=None, reframe=None, epoch=None, method convertRefFrame (line 89) | def convertRefFrame(self, reframe2, reframe, epoch=None): method ellipsoidalCartesian (line 94) | def ellipsoidalCartesian(self): method epoch (line 100) | def epoch(self): method epoch (line 106) | def epoch(self, epoch): method intersections2 (line 114) | def intersections2(self, radius, center2, radius2, sphere=True, method reframe (line 160) | def reframe(self): method reframe (line 166) | def reframe(self, reframe): method toLatLon (line 173) | def toLatLon(self, datum=None, height=None, **LatLon_and_kwds): # PYC... method toRefFrame (line 184) | def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, ... method toTransforms_ (line 210) | def toTransforms_(self, *transforms, **datum): # PYCHOK no cover class LatLonEllipsoidalBase (line 218) | class LatLonEllipsoidalBase(LatLonBase): method __init__ (line 230) | def __init__(self, latlonh, lon=None, height=0, datum=_WGS84, reframe=... method antipode (line 273) | def antipode(self, height=None): method convergence (line 288) | def convergence(self): method convertDatum (line 293) | def convertDatum(self, datum2): method convertRefFrame (line 298) | def convertRefFrame(self, reframe2): method datum (line 303) | def datum(self): method datum (line 309) | def datum(self, datum): method distanceTo2 (line 321) | def distanceTo2(self, other, wrap=False): method _elevation2 (line 350) | def _elevation2(self): method elevation2 (line 356) | def elevation2(self, adjust=True, datum=None, timeout=2): method ellipsoid (line 385) | def ellipsoid(self, datum=_WGS84): method ellipsoidalLatLon (line 395) | def ellipsoidalLatLon(self): method ellipsoids (line 400) | def ellipsoids(self, other): method epoch (line 424) | def epoch(self): method epoch (line 430) | def epoch(self, epoch): method Equidistant (line 439) | def Equidistant(self): method _etm (line 449) | def _etm(self): method gamma (line 455) | def gamma(self): method _geoidHeight2 (line 462) | def _geoidHeight2(self): method geoidHeight2 (line 468) | def geoidHeight2(self, adjust=False, datum=None, timeout=2): method intermediateTo (line 497) | def intermediateTo(self, other, fraction, height=None, wrap=False): #... method intersection3 (line 501) | def intersection3(self, end1, start2, end2, height=None, wrap=False, ... method intersections2 (line 556) | def intersections2(self, radius1, center2, radius2, height=None, wrap=... method isenclosedBy (line 611) | def isenclosedBy(self, points, wrap=False): method iteration (line 635) | def iteration(self): method midpointTo (line 641) | def midpointTo(self, other, height=None, fraction=_0_5, wrap=False): method nearestOn (line 662) | def nearestOn(self, point1, point2, within=True, height=None, wrap=Fal... method parse (line 710) | def parse(self, strllh, height=0, datum=None, epoch=None, reframe=None, method _Radjust2 (line 738) | def _Radjust2(self, adjust, datum, meter_text2): method reframe (line 760) | def reframe(self): method reframe (line 766) | def reframe(self, reframe): method scale (line 774) | def scale(self): method _toX8 (line 780) | def _toX8(self, toX8, **kwds): method toCartesian (line 785) | def toCartesian(self, height=None, **Cartesian_and_kwds): # PYCHOK si... method toCss (line 797) | def toCss(self, **toCss_kwds): method toDatum (line 807) | def toDatum(self, datum2, height=None, **name): method toEtm (line 832) | def toEtm(self, **toEtm8_kwds): method toLcc (line 843) | def toLcc(self, **toLcc_kwds): method toMgrs (line 853) | def toMgrs(self, center=False, **toUtmUps_kwds): method toOsgr (line 868) | def toOsgr(self, kTM=False, **toOsgr_kwds): method toRefFrame (line 881) | def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, ... method toTransform (line 907) | def toTransform(self, transform, inverse=False, datum=None, **LatLon_k... method toUps (line 932) | def toUps(self, center=False, **toUps8_kwds): method toUtm (line 947) | def toUtm(self, center=False, **toUtm8_kwds): method toUtmUps (line 965) | def toUtmUps(self, pole=NN, center=False, **toUtmUps8_kwds): method to3xyz (line 995) | def to3xyz(self): # PYCHOK no cover method triangulate (line 1005) | def triangulate(self, bearing1, other, bearing2, **height_wrap_tol): method trilaterate5 (line 1024) | def trilaterate5(self, distance1, point2, distance2, point3, distance3, method _ups (line 1082) | def _ups(self): # __dict__ value overwritten by method C{toUtmUps} method _upsOK (line 1088) | def _upsOK(self, pole=NN, falsed=True, **unused): method _utm (line 1098) | def _utm(self): # __dict__ value overwritten by method C{toUtmUps} method _utmOK (line 1104) | def _utmOK(self): function _lowerleft (line 1114) | def _lowerleft(utmups, center): function _nearestOn (line 1126) | def _nearestOn(point, point1, point2, within=True, height=None, wrap=Fal... function _set_reframe (line 1142) | def _set_reframe(inst, reframe): FILE: pygeodesy/ellipsoidalBaseDI.py class LatLonEllipsoidalBaseDI (line 45) | class LatLonEllipsoidalBaseDI(LatLonEllipsoidalBase): method bearingTo2 (line 50) | def bearingTo2(self, other, wrap=False): method destination (line 70) | def destination(self, distance, bearing, height=None): method destination2 (line 80) | def destination2(self, distance, bearing, height=None): method _Direct (line 106) | def _Direct(self, distance, bearing, LL, height): # overloaded by I{V... method _Direct2Tuple (line 118) | def _Direct2Tuple(self, LL, height, r): # in .ellipsoidalVincenty.py method distanceTo (line 128) | def distanceTo(self, other, wrap=False, **unused): # radius=R_M method distanceTo3 (line 145) | def distanceTo3(self, other, wrap=False): method finalBearingOn (line 171) | def finalBearingOn(self, distance, bearing): method finalBearingTo (line 184) | def finalBearingTo(self, other, wrap=False): method geodesic (line 203) | def geodesic(self): # overloaded by I{Karney}'s, N/A for I{Vincenty} method _g_gl_p3 (line 208) | def _g_gl_p3(self, start, end, exact, wrap): method initialBearingTo (line 217) | def initialBearingTo(self, other, wrap=False): method intermediateTo (line 235) | def intermediateTo(self, other, fraction, height=None, wrap=False): method intersecant2 (line 270) | def intersecant2(self, circle, start, end, exact=False, height=None, ... method _Inverse (line 313) | def _Inverse(self, other, wrap, **unused): # azis=False, overloaded b... method nearestOn8 (line 323) | def nearestOn8(self, points, closed=False, height=None, wrap=False, method plumbTo (line 405) | def plumbTo(self, start, end, exact=False, height=None, # PYCHOK sign... class _Box (line 440) | class _Box(object): method __init__ (line 447) | def __init__(self, center, distance): method overlaps (line 462) | def overlaps(self, lat1, lon1, lat2, lon2): class _Tol (line 484) | class _Tol(object): method __init__ (line 494) | def __init__(self, tol_m, E, lat, *lats): method degrees (line 508) | def degrees(self): method degrees2m (line 513) | def degrees2m(self, deg): method degError (line 518) | def degError(self, Error=_ValueError): method done (line 523) | def done(self, deg): method lat (line 533) | def lat(self): method mError (line 538) | def mError(self, m, Error=_ValueError): method meter (line 547) | def meter(self): method radius (line 553) | def radius(self): method reset (line 558) | def reset(self): function _Equidistant00 (line 565) | def _Equidistant00(equidistant, p1): function intersecant2 (line 576) | def intersecant2(center, circle, point, other, **exact_height_wrap_tol): function _intersect3 (line 603) | def _intersect3(s1, end1, s2, end2, height=None, wrap=False, # MCCABE 1... function _intersection3 (line 699) | def _intersection3(start1, end1, start2, end2, height=None, wrap=False, ... function _intersections2 (line 714) | def _intersections2(center1, radius1, center2, radius2, height=None, wra... function _intersects2 (line 729) | def _intersects2(c1, radius1, c2, radius2, height=None, wrap=False, # M... function _nearestOn2 (line 817) | def _nearestOn2(p, point1, point2, within=True, height=None, wrap=False,... function _nearestOn3 (line 837) | def _nearestOn3(p, p1, p2, A, within=True, height=None, tol=_TOL_M, FILE: pygeodesy/ellipsoidalExact.py class Cartesian (line 30) | class Cartesian(CartesianEllipsoidalBase): method toLatLon (line 34) | def toLatLon(self, **LatLon_and_kwds): # PYCHOK LatLon=LatLon, datum=... class LatLon (line 52) | class LatLon(LatLonEllipsoidalBaseDI): method Equidistant (line 59) | def Equidistant(self): method geodesicx (line 65) | def geodesicx(self): method toCartesian (line 72) | def toCartesian(self, **Cartesian_datum_kwds): # PYCHOK Cartesian=Car... function areaOf (line 91) | def areaOf(points, datum=_WGS84, wrap=True, polar=False): function intersection3 (line 119) | def intersection3(start1, end1, start2, end2, height=None, wrap=False, ... function intersections2 (line 168) | def intersections2(center1, radius1, center2, radius2, height=None, wrap... function isclockwise (line 217) | def isclockwise(points, datum=_WGS84, wrap=True, polar=False): function nearestOn (line 244) | def nearestOn(point, point1, point2, within=True, height=None, wrap=False, function perimeterOf (line 287) | def perimeterOf(points, closed=False, datum=_WGS84, wrap=True): FILE: pygeodesy/ellipsoidalGeodSolve.py class Cartesian (line 30) | class Cartesian(CartesianEllipsoidalBase): method toLatLon (line 34) | def toLatLon(self, **LatLon_and_kwds): # PYCHOK LatLon=LatLon, datum=... class LatLon (line 52) | class LatLon(LatLonEllipsoidalBaseDI): method Equidistant (line 60) | def Equidistant(self): method geodesicx (line 66) | def geodesicx(self): method toCartesian (line 73) | def toCartesian(self, **Cartesian_datum_kwds): # PYCHOK Cartesian=Car... function areaOf (line 90) | def areaOf(points, datum=_WGS84, wrap=True, polar=False): function intersection3 (line 115) | def intersection3(start1, end1, start2, end2, height=None, wrap=False, ... function intersections2 (line 167) | def intersections2(center1, radius1, center2, radius2, height=None, wrap... function isclockwise (line 216) | def isclockwise(points, datum=_WGS84, wrap=True, polar=False): function nearestOn (line 243) | def nearestOn(point, point1, point2, within=True, height=None, wrap=False, function perimeterOf (line 286) | def perimeterOf(points, closed=False, datum=_WGS84, wrap=True): FILE: pygeodesy/ellipsoidalKarney.py class Cartesian (line 48) | class Cartesian(CartesianEllipsoidalBase): method toLatLon (line 52) | def toLatLon(self, **LatLon_and_kwds): # PYCHOK LatLon=LatLon, datum=... class LatLon (line 69) | class LatLon(LatLonEllipsoidalBaseDI): method bearingTo (line 76) | def bearingTo(self, other, wrap=False): # PYCHOK no cover method Equidistant (line 82) | def Equidistant(self): method geodesic (line 88) | def geodesic(self): method toCartesian (line 96) | def toCartesian(self, **Cartesian_datum_kwds): # PYCHOK Cartesian=Car... function areaOf (line 113) | def areaOf(points, datum=_WGS84, wrap=True, polar=False): function intersection3 (line 142) | def intersection3(start1, end1, start2, end2, height=None, wrap=False, ... function intersections2 (line 194) | def intersections2(center1, radius1, center2, radius2, height=None, wrap... function isclockwise (line 243) | def isclockwise(points, datum=_WGS84, wrap=True, polar=False): function nearestOn (line 274) | def nearestOn(point, point1, point2, within=True, height=None, wrap=False, function perimeterOf (line 321) | def perimeterOf(points, closed=False, datum=_WGS84, wrap=True): FILE: pygeodesy/ellipsoidalNvector.py class Ned (line 57) | class Ned(_Ned): method __init__ (line 60) | def __init__(self, north, east, down, **name): method toRepr (line 65) | def toRepr(self, prec=None, fmt=Fmt.SQUARE, sep=_COMMASPACE_, **unused): class Cartesian (line 83) | class Cartesian(CartesianEllipsoidalBase): method Ecef (line 88) | def Ecef(self): method toLatLon (line 93) | def toLatLon(self, **LatLon_and_kwds): # PYCHOK LatLon=LatLon, datum=... method toNvector (line 110) | def toNvector(self, **Nvector_and_kwds): # PYCHOK Datums.WGS84 class LatLon (line 127) | class LatLon(LatLonNvectorBase, LatLonEllipsoidalBase): method _update (line 132) | def _update(self, updated, *attrs, **setters): # PYCHOK args method deltaTo (line 168) | def deltaTo(self, other, wrap=False, **Ned_and_kwds): method destinationNed (line 231) | def destinationNed(self, delta): method distanceTo (line 258) | def distanceTo(self, other, radius=None, wrap=False): method Ecef (line 283) | def Ecef(self): method equals (line 289) | def equals(self, other, eps=None): # PYCHOK no cover method isequalTo (line 294) | def isequalTo(self, other, eps=None): method intermediateTo (line 354) | def intermediateTo(self, other, fraction, height=None, wrap=False): method _rotation3 (line 379) | def _rotation3(self): method toCartesian (line 389) | def toCartesian(self, **Cartesian_and_kwds): # PYCHOK Cartesian=Carte... method toNvector (line 406) | def toNvector(self, **Nvector_and_kwds): # PYCHOK signature class Nvector (line 426) | class Nvector(NvectorBase): method __init__ (line 439) | def __init__(self, x_xyz, y=None, z=None, h=0, datum=None, ll=None, **... method datum (line 463) | def datum(self): method ellipsoidalNvector (line 469) | def ellipsoidalNvector(self): method toCartesian (line 474) | def toCartesian(self, **Cartesian_and_kwds): # PYCHOK Cartesian=Carte... method toLatLon (line 492) | def toLatLon(self, **LatLon_and_kwds): # PYCHOK height=None, LatLon=L... method unit (line 509) | def unit(self, ll=None): function _Ecef (line 522) | def _Ecef(): function meanOf (line 528) | def meanOf(points, datum=_WGS84, height=None, wrap=False, function nearestOn (line 553) | def nearestOn(point, point1, point2, within=True, height=None, wrap=False, function sumOf (line 600) | def sumOf(nvectors, Vector=Nvector, h=None, **Vector_kwds): function toNed (line 617) | def toNed(distance, bearing, elevation, Ned=Ned, **name): FILE: pygeodesy/ellipsoidalVincenty.py class VincentyError (line 84) | class VincentyError(_ValueError): class Cartesian (line 91) | class Cartesian(CartesianEllipsoidalBase): method Ecef (line 96) | def Ecef(self): method toLatLon (line 101) | def toLatLon(self, **LatLon_and_kwds): # PYCHOK LatLon=LatLon, datum=... class LatLon (line 119) | class LatLon(LatLonEllipsoidalBaseDI): method bearingTo (line 138) | def bearingTo(self, other, wrap=False): # PYCHOK no cover method Ecef (line 144) | def Ecef(self): method epsilon (line 150) | def epsilon(self): method epsilon (line 156) | def epsilon(self, epsilon): method iterations (line 166) | def iterations(self): method iterations (line 172) | def iterations(self, limit): method toCartesian (line 181) | def toCartesian(self, **Cartesian_datum_kwds): # PYCHOK Cartesian=Car... method _Direct (line 199) | def _Direct(self, distance, bearing, llr, height): method _Inverse (line 248) | def _Inverse(self, other, wrap, azis=True): # PYCHOK signature method _is_to (line 324) | def _is_to(self, other, anti): method _no_convergence (line 330) | def _no_convergence(self, e): function _AB2 (line 338) | def _AB2(u2): # WGS84 e22 = 0.00673949674227643 function _c2sm2 (line 347) | def _c2sm2(c2sm): function _Dl (line 352) | def _Dl(f, ca2, sa, s, cs, ss, c2sm, dl=_0_0): function _Ds (line 364) | def _Ds(B, cs, ss, c2sm, d): function _Ecef (line 375) | def _Ecef(): function _ellipsoidalOf (line 381) | def _ellipsoidalOf(_Of, points, **kwds): # helper for DEPRECATED areaOf... function _sincos22 (line 389) | def _sincos22(sa): function _sincostan3r (line 395) | def _sincostan3r(a, f): function areaOf (line 407) | def areaOf(points, **datum_wrap_polar): function intersection3 (line 413) | def intersection3(start1, end1, start2, end2, height=None, wrap=False, ... function intersections2 (line 465) | def intersections2(center1, radius1, center2, radius2, height=None, wrap... function nearestOn (line 514) | def nearestOn(point, point1, point2, within=True, height=None, wrap=False, function perimeterOf (line 563) | def perimeterOf(points, **closed_datum_wrap): FILE: pygeodesy/ellipsoids.py function _aux (line 109) | def _aux(lat, inverse, auxLat, clip=90): function _sin2cos2 (line 115) | def _sin2cos2(rad): class a_f2Tuple (line 130) | class a_f2Tuple(_NamedTuple): method __new__ (line 139) | def __new__(cls, a, f, **name): method b (line 162) | def b(self): method ellipsoid (line 167) | def ellipsoid(self, **name): method f_ (line 178) | def f_(self): class Curvature2Tuple (line 184) | class Curvature2Tuple(_NamedTuple): method transverse (line 192) | def transverse(self): class Ellipsoid (line 198) | class Ellipsoid(_NamedEnumItem): method __init__ (line 212) | def __init__(self, a, b=None, f_=None, f=None, **name): method __eq__ (line 284) | def __eq__(self, other): method __hash__ (line 295) | def __hash__(self): method a (line 299) | def a(self): method a2 (line 307) | def a2(self): method a2_ (line 313) | def a2_(self): method A (line 319) | def A(self): method a_b (line 344) | def a_b(self): method a2_b (line 350) | def a2_b(self): method a2_b2 (line 365) | def a2_b2(self): method a_f (line 372) | def a_f(self): method _albersCyl (line 380) | def _albersCyl(self): method AlphaKs (line 386) | def AlphaKs(self): method area (line 401) | def area(self): method areax (line 410) | def areax(self): method _assert (line 419) | def _assert(self, val, eps=_TOL, f0=_0_0, Error=_AssertionError, txt=N... method auxAuthalic (line 432) | def auxAuthalic(self, lat, inverse=False): method auxConformal (line 452) | def auxConformal(self, lat, inverse=False): method auxGeocentric (line 471) | def auxGeocentric(self, lat, inverse=False, height=_0_0): method auxIsometric (line 502) | def auxIsometric(self, lat, inverse=False): method auxParametric (line 527) | def auxParametric(self, lat, inverse=False): method auxRectifying (line 547) | def auxRectifying(self, lat, inverse=False): method b (line 573) | def b(self): method b_a (line 581) | def b_a(self): method b2 (line 589) | def b2(self): method b2_a (line 595) | def b2_a(self): method b2_a2 (line 603) | def b2_a2(self): method _Betad (line 609) | def _Betad(self, lat, inverse=False): method BetaKs (line 617) | def BetaKs(self): method c (line 632) | def c(self): # PYCHOK no cover method c2 (line 637) | def c2(self): method c2x (line 650) | def c2x(self): method _c2f (line 659) | def _c2f(self, c2x): method circle4 (line 673) | def circle4(self, lat): method degrees2m (line 708) | def degrees2m(self, deg, lat=0): method distance2 (line 725) | def distance2(self, lat0, lon0, lat1, lon1): method e (line 754) | def e(self): method e12 (line 762) | def e12(self): # see property ._e12 method e2 (line 772) | def e2(self): method e2abs (line 779) | def e2abs(self): method e21 (line 785) | def e21(self): method e22 (line 795) | def e22(self): method e22abs (line 802) | def e22abs(self): method e32 (line 808) | def e32(self): method e32abs (line 815) | def e32abs(self): method e4 (line 821) | def e4(self): method ecef (line 832) | def ecef(self, Ecef=None): method _elliptic_e12 (line 846) | def _elliptic_e12(self): # see I{Karney}'s Ellipsoid._e12 method _elliptic_e22 (line 853) | def _elliptic_e22(self): # aka ._elliptic_ep2 method equatorimeter (line 861) | def equatorimeter(self): method e2s (line 866) | def e2s(self, s): method e2s2 (line 877) | def e2s2(self, s): method es (line 898) | def es(self): method es_atanh (line 906) | def es_atanh(self, x): method _es_atanh (line 918) | def _es_atanh(self, x): # see .albers._atanhee, .AuxLat._atanhee method es_c (line 927) | def es_c(self): method es_tauf (line 932) | def es_tauf(self, taup): method _es_tauf3 (line 953) | def _es_tauf3(self, taup, T, N=9): # in .utm.Utm._toLLEB method es_taupf (line 968) | def es_taupf(self, tau): method _es_taupf2 (line 981) | def _es_taupf2(self, tau): method _exp_es_atanh_1 (line 993) | def _exp_es_atanh_1(self): method f (line 999) | def f(self): method f_ (line 1005) | def f_(self): method f1 (line 1011) | def f1(self): method f2 (line 1019) | def f2(self): method geodesic (line 1025) | def geodesic(self): method geodesic_ (line 1029) | def geodesic_(self, exact=True): method _Geodesics (line 1053) | def _Geodesics(self): method geodesicw (line 1066) | def geodesicw(self): method geodesicx (line 1077) | def geodesicx(self): method geodsolve (line 1085) | def geodsolve(self): method geodsolve (line 1096) | def geodsolve(self, path): method hartzell4 (line 1103) | def hartzell4(self, pov, los=None): method _hash (line 1136) | def _hash(self): method height4 (line 1139) | def height4(self, xyz, normal=True): method _heightB (line 1197) | def _heightB(self, sa, ca, z, p): # in ecef.EcefSudano, ecec.EcefVeness method _heightMax (line 1208) | def _heightMax(self): method _hubeny_2 (line 1213) | def _hubeny_2(self, phi2, phi1, lam21, scaled=True, squared=True): method isEllipsoidal (line 1222) | def isEllipsoidal(self): method isOblate (line 1228) | def isOblate(self): method isProlate (line 1235) | def isProlate(self): method isSpherical (line 1242) | def isSpherical(self): method _Kseries (line 1247) | def _Kseries(self, *AB8Ks): method KsOrder (line 1269) | def KsOrder(self): method KsOrder (line 1275) | def KsOrder(self, order): method L (line 1288) | def L(self): method Llat (line 1296) | def Llat(self, lat): method _Lpd (line 1311) | def _Lpd(self): method _Lpr (line 1317) | def _Lpr(self): method majoradius (line 1323) | def majoradius(self): # PYCHOK no cover method m2degrees (line 1327) | def m2degrees(self, distance, lat=0): method m2radians (line 1343) | def m2radians(self, distance, lat=0): method minoradius (line 1361) | def minoradius(self): # PYCHOK no cover method n (line 1366) | def n(self): method polarimeter (line 1379) | def polarimeter(self): method quarteradius (line 1387) | def quarteradius(self): # PYCHOK no cover method R1 (line 1392) | def R1(self): method R2 (line 1403) | def R2(self): method R2x (line 1418) | def R2x(self): method R3 (line 1428) | def R3(self): method radians2m (line 1438) | def radians2m(self, rad, lat=0): method Rbiaxial (line 1457) | def Rbiaxial(self): method Rgeocentric (line 1469) | def Rgeocentric(self, lat): method Rgeometric (line 1496) | def Rgeometric(self): method rhumb_ (line 1504) | def rhumb_(self, exact=True): method rhumbaux (line 1527) | def rhumbaux(self): method rhumbekx (line 1535) | def rhumbekx(self): method _Rhumbs (line 1543) | def _Rhumbs(self): method rhumbsolve (line 1551) | def rhumbsolve(self): method rhumbsolve (line 1562) | def rhumbsolve(self, path): method rhumbx (line 1570) | def rhumbx(self): method Rlat (line 1574) | def Rlat(self, lat): method roc1_ (line 1600) | def roc1_(self, sa, ca=None): method roc2 (line 1628) | def roc2(self, lat, scaled=False): method roc2_ (line 1647) | def roc2_(self, phi, scaled=False): method rocAzimuth (line 1678) | def rocAzimuth(self, lat, azimuth): method rocBearing (line 1686) | def rocBearing(self, lat, bearing): method _rocDirectional (line 1704) | def _rocDirectional(self, lat, deg): method rocEquatorial2 (line 1721) | def rocEquatorial2(self): method rocGauss (line 1732) | def rocGauss(self, lat): method rocMean (line 1754) | def rocMean(self, lat): method rocMeridional (line 1773) | def rocMeridional(self, lat): method rocPrimeVertical (line 1791) | def rocPrimeVertical(self, lat): method Rquadratic (line 1812) | def Rquadratic(self): # PYCHOK no cover method Rr (line 1817) | def Rr(self): # PYCHOK no cover method Rrectifying (line 1822) | def Rrectifying(self): method Rs (line 1833) | def Rs(self): # PYCHOK no cover method Rtriaxial (line 1838) | def Rtriaxial(self): method toEllipse (line 1850) | def toEllipse(self, **name): method toEllipsoid2 (line 1857) | def toEllipsoid2(self, **name): method toStr (line 1866) | def toStr(self, prec=8, terse=4, **sep_name): # PYCHOK expected method toTriaxial (line 1887) | def toTriaxial(self, **name): method _triaxial (line 1901) | def _triaxial(self): method volume (line 1909) | def volume(self): class Ellipsoid2 (line 1917) | class Ellipsoid2(Ellipsoid): method __init__ (line 1920) | def __init__(self, a, f=None, **name): function _ispherical_a_b (line 1943) | def _ispherical_a_b(a, b): function _ispherical_f (line 1949) | def _ispherical_f(f): function _ispherical_f_ (line 1955) | def _ispherical_f_(f_): function a_b2e (line 1962) | def a_b2e(a, b): function a_b2e2 (line 1976) | def a_b2e2(a, b): function a_b2e22 (line 1990) | def a_b2e22(a, b): function a_b2e32 (line 2004) | def a_b2e32(a, b): function _a2b2e2 (line 2019) | def _a2b2e2(a, b, a2=True, b2=True): function a_b2f (line 2032) | def a_b2f(a, b): function a_b2f_ (line 2047) | def a_b2f_(a, b): function a_b2f2 (line 2062) | def a_b2f2(a, b): function a_b2n (line 2077) | def a_b2n(a, b): function a_f2b (line 2092) | def a_f2b(a, f): function a_f_2b (line 2104) | def a_f_2b(a, f_): function b_f2a (line 2116) | def b_f2a(b, f): function b_f_2a (line 2129) | def b_f_2a(b, f_): function e2f (line 2143) | def e2f(e): function e22f (line 2155) | def e22f(e2): function f2e2 (line 2165) | def f2e2(f): function f2e22 (line 2182) | def f2e22(f): function f2e32 (line 2201) | def f2e32(f): function f_2f (line 2220) | def f_2f(f_): function f2f_ (line 2234) | def f2f_(f): function f2f2 (line 2248) | def f2f2(f): function f2n (line 2267) | def f2n(f): function n2e2 (line 2285) | def n2e2(n): function n2f (line 2303) | def n2f(n): function n2f_ (line 2319) | def n2f_(n): class Ellipsoids (line 2331) | class Ellipsoids(_NamedEnum): method _Lazy (line 2335) | def _Lazy(self, a, b, f_, **kwds): FILE: pygeodesy/elliptic.py class _Cs (line 103) | class _Cs(_Enum): class Elliptic (line 109) | class Elliptic(_Named): method __init__ (line 121) | def __init__(self, k2=0, alpha2=0, kp2=None, alphap2=None, **name): method alpha2 (line 138) | def alpha2(self): method alphap2 (line 144) | def alphap2(self): method _B3 (line 149) | def _B3(self, x): method _B4 (line 174) | def _B4(self): method cD (line 200) | def cD(self): method _cDEKEeps (line 207) | def _cDEKEeps(self): method cE (line 243) | def cE(self): method _cE (line 249) | def _cE(self, kp2): # compl integr 2nd kind method cG (line 253) | def cG(self): method _cGHPi (line 260) | def _cGHPi(self): method cH (line 301) | def cH(self): method cK (line 308) | def cK(self): method _cK (line 314) | def _cK(self, kp2): # compl integr 1st kind method cKE (line 318) | def cKE(self): method cPi (line 325) | def cPi(self): method deltaD (line 331) | def deltaD(self, sn, cn, dn): method deltaE (line 344) | def deltaE(self, sn, cn, dn): method deltaEinv (line 357) | def deltaEinv(self, stau, ctau): method deltaF (line 376) | def deltaF(self, sn, cn, dn): method deltaG (line 389) | def deltaG(self, sn, cn, dn): method deltaH (line 402) | def deltaH(self, sn, cn, dn): method deltaPi (line 415) | def deltaPi(self, sn, cn, dn): method _Einv (line 429) | def _Einv(self, x): method eps (line 460) | def eps(self): method fD (line 465) | def fD(self, phi_or_sn, cn=None, dn=None): method fDelta (line 487) | def fDelta(self, sn, cn): method fE (line 504) | def fE(self, phi_or_sn, cn=None, dn=None): method fEd (line 544) | def fEd(self, deg): method fEinv (line 564) | def fEinv(self, x): method fF (line 579) | def fF(self, phi_or_sn, cn=None, dn=None): method fG (line 602) | def fG(self, phi_or_sn, cn=None, dn=None): method fH (line 627) | def fH(self, phi_or_sn, cn=None, dn=None): method fPi (line 651) | def fPi(self, phi_or_sn, cn=None, dn=None): method _fXa (line 668) | def _fXa(self, phi_or_sn, cn, dn, aX, cX, deltaX): method _fXf (line 686) | def _fXf(self, phi_or_sn, cn, dn, cX, deltaX, fX, k2_0=False, kp2_0=Fa... method _jam (line 710) | def _jam(self, x): method _jamac2 (line 732) | def _jamac2(self): method k2 (line 759) | def k2(self): method kp2 (line 765) | def kp2(self): method reset (line 770) | def reset(self, k2=0, alpha2=0, kp2=None, alphap2=None): # MCCABE 13 method _reset (line 789) | def _reset(self, k2, alpha2, kp2, alphap2): method sncndn (line 823) | def sncndn(self, x, jam=False): method _sncndn3 (line 850) | def _sncndn3(self, phi): method fRC (line 857) | def fRC(x, y): method fRD (line 868) | def fRD(x, y, z, *over): method fRF (line 883) | def fRF(x, y, z=0): method _fRF3RD (line 898) | def _fRF3RD(x, z, m): # in .auxilats.AuxDLat.DE, -.AuxLat.Rectifying method fRG (line 909) | def fRG(x, y, z=0): method fRJ (line 929) | def fRJ(x, y, z, P): # *over class _Ek (line 945) | class _Ek(Elliptic): method __init__ (line 954) | def __init__(self, k2): class EllipticError (line 962) | class EllipticError(_ValueError): class Elliptic3Tuple (line 968) | class Elliptic3Tuple(_NamedTuple): class _Hdot (line 975) | class _Hdot(dict): method __call__ (line 978) | def __call__(self, F, h, *Xys): class _List (line 993) | class _List(list): method __init__ (line 998) | def __init__(self, *xyzp): # x, y, z [, P] method a0 (line 1001) | def a0(self, n): method amrs4 (line 1011) | def amrs4(self, y, Tol, inst=None): method rescale (line 1037) | def rescale(self, am, *xs): method threshold (line 1046) | def threshold(self, Tol): class _Qdot3 (line 1063) | class _Qdot3(list): method __init__ (line 1066) | def __init__(self, x, y, z, *unused): # PYCHOK signature method __call__ (line 1070) | def __call__(self, a): method __float__ (line 1078) | def __float__(self): function _abm3 (line 1082) | def _abm3(x, y, inst=None): function _deltaX (line 1106) | def _deltaX(sn, cn, dn, cX, fX): function _ellipticError (line 1123) | def _ellipticError(where, *args, **kwds_cause_txt): function _Hsum (line 1138) | def _Hsum(S, e1, E2, E3, E4, E5, over): function _3over (line 1160) | def _3over(a, b): function _rC (line 1166) | def _rC(x, y): function _RD (line 1188) | def _RD(x, y, z, over=_0_0, inst=None): function _Rdot (line 1209) | def _Rdot(x, y, z, start3): function _rF2 (line 1219) | def _rF2(x, y, inst=None): # 2-arg version, z=0 function _RF3 (line 1227) | def _RF3(x, y, z, inst=None): # 3-arg version function _rG2 (line 1251) | def _rG2(x, y, inst=None, PI_=PI_4): # 2-args function _rG3 (line 1261) | def _rG3(x, y, z): # 3-arg version # in .triaxials.bases function _RJ (line 1272) | def _RJ(x, y, z, P, over=_0_0, inst=None): class _RJfma (line 1307) | class _RJfma(object): method __init__ (line 1310) | def __init__(self, *args): method ma (line 1313) | def ma(self, b, c): FILE: pygeodesy/epsg.py class Epsg (line 43) | class Epsg(Int): method __new__ (line 52) | def __new__(cls, eisu, **name): method __repr__ (line 95) | def __repr__(self): method __str__ (line 98) | def __str__(self): method band (line 102) | def band(self): method hemisphere (line 109) | def hemisphere(self): method utmups (line 115) | def utmups(self): method utmupsStr (line 120) | def utmupsStr(self, B=False): method zone (line 130) | def zone(self): class EPSGError (line 136) | class EPSGError(_ValueError): function decode2 (line 142) | def decode2(epsg): function encode (line 181) | def encode(zone, hemipole=NN, band=NN): FILE: pygeodesy/errors.py function _error_cause (line 55) | def _error_cause(inst, cause=None): function _error_cause (line 77) | def _error_cause(inst, **unused): # PYCHOK expected class _AssertionError (line 81) | class _AssertionError(AssertionError): method __init__ (line 84) | def __init__(self, *args, **kwds): class _AttributeError (line 88) | class _AttributeError(AttributeError): method __init__ (line 91) | def __init__(self, *args, **kwds): class _ConvergenceError (line 95) | class _ConvergenceError(ValueError): # in .ellipses, .elliptic method __init__ (line 98) | def __init__(self, maxit, d, tol, **thresh): # PYCHOK cause=None class _ImportError (line 103) | class _ImportError(ImportError): method __init__ (line 106) | def __init__(self, *args, **kwds): class _IndexError (line 110) | class _IndexError(IndexError): method __init__ (line 113) | def __init__(self, *args, **kwds): class _KeyError (line 117) | class _KeyError(KeyError): method __init__ (line 120) | def __init__(self, *args, **kwds): # txt=_invalid_ class _NameError (line 124) | class _NameError(NameError): method __init__ (line 127) | def __init__(self, *args, **kwds): class _NotImplementedError (line 131) | class _NotImplementedError(NotImplementedError): method __init__ (line 134) | def __init__(self, *args, **kwds): class _OverflowError (line 138) | class _OverflowError(OverflowError): method __init__ (line 141) | def __init__(self, *args, **kwds): # txt=_invalid_ class _TypeError (line 145) | class _TypeError(TypeError): method __init__ (line 148) | def __init__(self, *args, **kwds): function _TypesError (line 152) | def _TypesError(name, value, *Types, **kwds): class _UnexpectedError (line 161) | class _UnexpectedError(TypeError): # note, a TypeError! method __init__ (line 164) | def __init__(self, *args, **kwds): class _ValueError (line 176) | class _ValueError(ValueError): method __init__ (line 179) | def __init__(self, *args, **kwds): # ..., cause=None, txt=_invalid_, ... class _ZeroDivisionError (line 183) | class _ZeroDivisionError(ZeroDivisionError): method __init__ (line 186) | def __init__(self, *args, **kwds): class AuxError (line 190) | class AuxError(_ValueError): class ClipError (line 196) | class ClipError(_ValueError): method __init__ (line 199) | def __init__(self, *name_n_corners, **txt_cause): class CrossError (line 216) | class CrossError(_ValueError): class GeodesicError (line 223) | class GeodesicError(_ValueError): class IntersectionError (line 231) | class IntersectionError(_ValueError): # in .ellipsoidalBaseDI, .formy, ... method __init__ (line 234) | def __init__(self, *args, **kwds): class LenError (line 244) | class LenError(_ValueError): # in .ecef, .fmath, .heights, .iters, .named method __init__ (line 247) | def __init__(self, where, **lens_txt): # txt=None class LimitError (line 267) | class LimitError(_ValueError): class MGRSError (line 278) | class MGRSError(_ValueError): class NumPyError (line 284) | class NumPyError(_ValueError): class ParseError (line 290) | class ParseError(_ValueError): # in .dms, .elevations, .utmupsBase class PointsError (line 296) | class PointsError(_ValueError): # in .clipy, .frechet, ... class RangeError (line 302) | class RangeError(_ValueError): class RhumbError (line 313) | class RhumbError(_ValueError): class TriangleError (line 320) | class TriangleError(_ValueError): # in .resections, .vector2d class SciPyError (line 326) | class SciPyError(PointsError): class SciPyWarning (line 332) | class SciPyWarning(PointsError): class TRFError (line 346) | class TRFError(_ValueError): # in .ellipsoidalBase, .trf, .units class UnitError (line 353) | class UnitError(LimitError): # in .named, .units class VectorError (line 360) | class VectorError(_ValueError): # in .nvectorBase, .vector3d, .vector3d... function _an (line 366) | def _an(noun): function _and (line 374) | def _and(*words): function _and_or (line 380) | def _and_or(last, *words): function crosserrors (line 392) | def crosserrors(raiser=None): function _error_init (line 410) | def _error_init(Error, inst, args, fmt_name_value='%s (%r)', txt_not_=NN, function _error_under (line 460) | def _error_under(inst): function exception_chaining (line 470) | def exception_chaining(exc=None): function _ImmutableError (line 489) | def _ImmutableError(inst, attr, value=_del_, Error=_TypeError): # PYCHO... function _incompatible (line 499) | def _incompatible(this): function _InvalidError (line 505) | def _InvalidError(Error=_ValueError, **txt_name_values_cause): # txt=_i... function isError (line 519) | def isError(exc): function _IsnotError (line 539) | def _IsnotError(*types__, **name_value_Error_cause): # name=value [, Er... function limiterrors (line 558) | def limiterrors(raiser=None): function _or (line 574) | def _or(*words): function _parseX (line 580) | def _parseX(parser, *args, **Error_name_values): # name=value[, ..., Er... function rangerrors (line 600) | def rangerrors(raiser=None): function _SciPyIssue (line 616) | def _SciPyIssue(exc, *extras): # PYCHOK no cover function _xAssertionError (line 625) | def _xAssertionError(where, *args, **kwds): function _xattr (line 633) | def _xattr(obj, **name_default): function _xattrs (line 645) | def _xattrs(inst, other, *attrs): # see .errors._xattr function _xcallable (line 673) | def _xcallable(**names_callables): function _xdatum (line 681) | def _xdatum(datum1, datum2, Error=None): function _xellipsoidal (line 694) | def _xellipsoidal(**name_value): # see _xellipsoidall elel function _xellipsoidall (line 708) | def _xellipsoidall(point): # ... elel, see _xellipsoidal function _xellipsoids (line 720) | def _xellipsoids(E1, E2, Error=_ValueError): # see .ellipsoidalBase function _XError (line 728) | def _XError(Error, *args, **kwds): function _xError (line 742) | def _xError(exc, *args, **kwds): function _xError2 (line 752) | def _xError2(exc): # in .constants, .fsums, .lazily, .vector2d function _xgeodesics (line 776) | def _xgeodesics(G1, G2, Error=_ValueError): # see .geodesici function _xkwds (line 787) | def _xkwds(kwds, **dflts): function _xkwds (line 795) | def _xkwds(kwds, **dflts): # PYCHOK expected function _xkwds_get (line 832) | def _xkwds_get(kwds, **name_default): function _xkwds_get1 (line 852) | def _xkwds_get1(kwds, **name_default): function _xkwds_item2 (line 863) | def _xkwds_item2(kwds): function _xkwds_kwds (line 873) | def _xkwds_kwds(kwds, **names_defaults): # in .geodesici # PYCHOK no c... function _xkwds_not (line 882) | def _xkwds_not(*args, **kwds): function _xkwds_pop (line 888) | def _xkwds_pop(kwds, **name_default): function _xkwds_pop2 (line 898) | def _xkwds_pop2(kwds, **name_default): function _Xorder (line 911) | def _Xorder(_Coeffs, Error, **Xorder): # in .auxLat, .ktm, .rhumb.bases... function _xsError (line 921) | def _xsError(X, xs, i, x, *n, **kwds): # in .fmath, ._fstats, .fsums function _xStrError (line 934) | def _xStrError(*Refs, **name_value_Error): # in .gars, .geohash, .wgrs FILE: pygeodesy/etm.py class ETMError (line 105) | class ETMError(UTMError): class Etm (line 112) | class Etm(Utm): method exactTM (line 133) | def exactTM(self): method exactTM (line 141) | def exactTM(self, exactTM): method parse (line 155) | def parse(self, strETM, **name): method parseETM (line 172) | def parseETM(self, strETM): # PYCHOK no cover method toLatLon (line 177) | def toLatLon(self, LatLon=None, unfalse=True, **unused): # PYCHOK exp... method _toLLEB (line 196) | def _toLLEB(self, unfalse=True, **unused): # PYCHOK signature method toUtm (line 212) | def toUtm(self): # PYCHOK signature class ExactTransverseMercator (line 220) | class ExactTransverseMercator(_NamedBase): method __init__ (line 238) | def __init__(self, datum=_WGS84, lon0=0, k0=_K0_UTM, extendp=False, ra... method datum (line 279) | def datum(self): method datum (line 285) | def datum(self, datum): method _e (line 295) | def _e(self): method _1_e_90 (line 301) | def _1_e_90(self): # PYCHOK no cover method ellipsoid (line 307) | def ellipsoid(self): method _e_PI_2 (line 313) | def _e_PI_2(self): method _e_PI_4_ (line 319) | def _e_PI_4_(self): method _1_e_PI_2 (line 325) | def _1_e_PI_2(self): method _1_2e_PI_2 (line 331) | def _1_2e_PI_2(self): method equatoradius (line 337) | def equatoradius(self): method _e_TAYTOL (line 345) | def _e_TAYTOL(self): method _Eu (line 351) | def _Eu(self): method _Eu_cE (line 357) | def _Eu_cE(self): method _Eu_2cE_ (line 362) | def _Eu_2cE_(self, xi): method _Eu_cE_4 (line 368) | def _Eu_cE_4(self): method _Eu_cK (line 374) | def _Eu_cK(self): method _Eu_cK_cE (line 380) | def _Eu_cK_cE(self): method _Eu_2cK_PI (line 386) | def _Eu_2cK_PI(self): method _Ev (line 392) | def _Ev(self): method _Ev_cK (line 398) | def _Ev_cK(self): method _Ev_cKE (line 404) | def _Ev_cKE(self): method _Ev_3cKE_4 (line 410) | def _Ev_3cKE_4(self): method _Ev_5cKE_4 (line 416) | def _Ev_5cKE_4(self): method extendp (line 422) | def extendp(self): method flattening (line 428) | def flattening(self): method forward (line 435) | def forward(self, lat, lon, lon0=None, jam=_K_2_4, **name): # MCCABE 13 method _Inv03 (line 495) | def _Inv03(self, psi, dlam, _3_mv_e): # (xi, deta, _3_mv) method iteration (line 513) | def iteration(self): method k0 (line 521) | def k0(self): method k0 (line 527) | def k0(self, k0): method _k0_a (line 538) | def _k0_a(self): method lon0 (line 544) | def lon0(self): method lon0 (line 550) | def lon0(self, lon0): method majoradius (line 558) | def majoradius(self): # PYCHOK no cover method _1_mu_2 (line 563) | def _1_mu_2(self): method _3_mv (line 569) | def _3_mv(self): method _3_mv_e (line 575) | def _3_mv_e(self): method _Newton2 (line 580) | def _Newton2(self, taup, lam, u, v, C, *psi): # or (xi, eta, u, v) method raiser (line 624) | def raiser(self): method raiser (line 630) | def raiser(self, raiser): method reset (line 636) | def reset(self, lat0, lon0): method _resets (line 652) | def _resets(self, datum): method reverse (line 674) | def reverse(self, x, y, lon0=None, jam=_K_2_4, **name): method _scaled2 (line 730) | def _scaled2(self, tau, d2, snu, cnu, dnu, snv, cnv, dnv): method _sigma3 (line 771) | def _sigma3(self, v, snu, cnu, dnu, snv, cnv, dnv): method _sigmaDwd2 (line 798) | def _sigmaDwd2(self, snu, cnu, dnu, snv, cnv, dnv): method _sigmaInv2 (line 818) | def _sigmaInv2(self, xi, eta): method _sigmaInv04 (line 833) | def _sigmaInv04(self, xi, eta): method _sncndn6 (line 874) | def _sncndn6(self, u, v, **jam): method toStr (line 882) | def toStr(self, joined=_COMMASPACE_, **kwds): # PYCHOK signature method _zeta3 (line 896) | def _zeta3(self, unused, snu, cnu, dnu, snv, cnv, dnv): # _sigma3 sig... method _zetaDwd2 (line 926) | def _zetaDwd2(self, snu, cnu, dnu, snv, cnv, dnv): method _zetaInv2 (line 948) | def _zetaInv2(self, taup, lam): method _zetaInv04 (line 964) | def _zetaInv04(self, psi, lam): method _zetaScaled (line 1010) | def _zetaScaled(self, sncndn6, ll=True): function _copysignOVERFLOW (line 1029) | def _copysignOVERFLOW(x): function parseETM5 (line 1035) | def parseETM5(strUTM, datum=_WGS84, Etm=Etm, falsed=True, **name): function toEtm8 (line 1059) | def toEtm8(latlon, lon=None, datum=None, Etm=Etm, falsed=True, function _main (line 1106) | def _main(): FILE: pygeodesy/fmath.py class Fdot (line 37) | class Fdot(Fsum): method __init__ (line 40) | def __init__(self, a, *b, **start_name_f2product_nonfinites_RESIDUAL): class Fdot_ (line 70) | class Fdot_(Fdot): # in .elliptic method __init__ (line 73) | def __init__(self, *xys, **start_name_f2product_nonfinites_RESIDUAL): class Fhorner (line 87) | class Fhorner(Fsum): method __init__ (line 90) | def __init__(self, x, *cs, **incx_name_f2product_nonfinites_RESIDUAL): class Fhypot (line 114) | class Fhypot(Fsum): method __init__ (line 117) | def __init__(self, *xs, **root_name_f2product_nonfinites_RESIDUAL_rais... class Fpolynomial (line 145) | class Fpolynomial(Fsum): method __init__ (line 148) | def __init__(self, x, *cs, **name_f2product_nonfinites_RESIDUAL): class Fpowers (line 172) | class Fpowers(Fsum): method __init__ (line 175) | def __init__(self, power, *xs, **name_f2product_nonfinites_RESIDUAL_ra... class Froot (line 196) | class Froot(Fsum): method __init__ (line 199) | def __init__(self, root, *xs, **name_f2product_nonfinites_RESIDUAL_rai... class Fcbrt (line 221) | class Fcbrt(Froot): method __init__ (line 224) | def __init__(self, *xs, **name_f2product_nonfinites_RESIDUAL_raiser): class Fsqrt (line 232) | class Fsqrt(Froot): method __init__ (line 235) | def __init__(self, *xs, **name_f2product_nonfinites_RESIDUAL_raiser): function bqrt (line 243) | def bqrt(x): function _cbrt (line 264) | def _cbrt(x): function cbrt (line 273) | def cbrt(x): function cbrt2 (line 291) | def cbrt2(x): # PYCHOK attr function euclid (line 303) | def euclid(x, y, *xy0): function euclid_ (line 320) | def euclid_(*xs): function facos1 (line 348) | def facos1(x): function fasin1 (line 367) | def fasin1(x): # PYCHOK no cover function _fast (line 375) | def _fast(x, *cs): function fatan (line 384) | def fatan(x): function fatan1 (line 399) | def fatan1(x): function fatan2 (line 414) | def fatan2(y, x): function favg (line 437) | def favg(a, b, f=_0_5, nonfinites=True): function fdot (line 451) | def fdot(xs, *ys, **start_f2product_nonfinites): function fdot_ (line 472) | def fdot_(*xys, **start_f2product_nonfinites): function fdot3 (line 485) | def fdot3(xs, ys, zs, **start_f2product_nonfinites): function fhorner (line 509) | def fhorner(x, *cs, **incx): function fidw (line 521) | def fidw(xs, ds, beta=2): function _fma (line 586) | def _fma(x, y, z): # no need for accuracy function fma (line 590) | def fma(x, y, z, **nonfinites): # **raiser function _Fm2 (line 607) | def _Fm2(x, nonfinites=None, **raiser): function fmean (line 613) | def fmean(xs, nonfinites=True): function fmean_ (line 631) | def fmean_(*xs, **nonfinites): function f2mul_ (line 639) | def f2mul_(x, *ys, **nonfinites): # **raiser function fpolynomial (line 656) | def fpolynomial(x, *cs, **over_f2product_nonfinites): function fpowers (line 670) | def fpowers(x, n, alts=0): function fprod (line 703) | def fprod(xs, start=1): function frandoms (line 719) | def frandoms(n, seeded=None): function frange (line 752) | def frange(start, number, step=1): function freduce (line 777) | def freduce(f, xs, *start): function fremainder (line 791) | def fremainder(x, y): function hypot_ (line 839) | def hypot_(*xs): function hypot (line 869) | def hypot(x, y): function _Hypot (line 885) | def _Hypot(*xs): function hypot1 (line 891) | def hypot1(x): function hypot2 (line 908) | def hypot2(x, y, *xy0): function hypot2_ (line 927) | def hypot2_(*xs): function _map0 (line 946) | def _map0(_f, x, y, x0=_0_0, y0=_0_0, *unused): function norm2 (line 950) | def norm2(x, y, *xy0): function norm_ (line 976) | def norm_(*xs): function polar2 (line 998) | def polar2(x, y, *xy0): function polar2d (line 1011) | def polar2d(x, y, *xy0): function _powers (line 1024) | def _powers(x, n): function _root (line 1033) | def _root(x, p, where): function sqrt0 (line 1047) | def sqrt0(x, Error=None): function sqrt3 (line 1067) | def sqrt3(x): function sqrt_a (line 1084) | def sqrt_a(h, b): function zcrt (line 1123) | def zcrt(x): function zqrt (line 1140) | def zqrt(x): FILE: pygeodesy/formy.py function angle2chord (line 53) | def angle2chord(rad, radius=R_M): function _anti2 (line 70) | def _anti2(a, b, n_2, n, n2): function antipode (line 82) | def antipode(lat, lon, **name): function antipode_ (line 98) | def antipode_(phi, lam, **name): function bearing (line 114) | def bearing(lat1, lon1, lat2, lon2, **final_wrap): function bearing_ (line 132) | def bearing_(phi1, lam1, phi2, lam2, final=False, wrap=False): function _bearingTo2 (line 165) | def _bearingTo2(p1, p2, wrap=False): # for points.ispolar, sphericalTri... function chord2angle (line 180) | def chord2angle(chord, radius=R_M): function compassAngle (line 204) | def compassAngle(lat1, lon1, lat2, lon2, adjust=True, wrap=False): function cosineLaw (line 233) | def cosineLaw(lat1, lon1, lat2, lon2, corr=0, earth=None, wrap=False, function cosineLaw_ (line 272) | def cosineLaw_(phi2, phi1, lam21, corr=0, earth=None, datum=_WGS84): function _d3 (line 339) | def _d3(wrap, lat1, lon1, lat2, lon2): function _dE (line 349) | def _dE(fun_, earth, wrap, *lls, **corr): function _dS (line 357) | def _dS(fun_, radius, wrap, *lls, **adjust): function _ellipsoidal (line 371) | def _ellipsoidal(earth, where): function equirectangular (line 380) | def equirectangular(lat1, lon1, lat2, lon2, radius=R_M, **adjust_limit_w... function _equirectangular (line 407) | def _equirectangular(lat1, lon1, lat2, lon2, **adjust_limit_wrap): function equirectangular4 (line 415) | def equirectangular4(lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap... function euclidean (line 465) | def euclidean(lat1, lon1, lat2, lon2, radius=R_M, adjust=True, wrap=False): function euclidean_ (line 494) | def euclidean_(phi2, phi1, lam21, adjust=True): function excessAbc_ (line 513) | def excessAbc_(A, b, c): function excessCagnoli_ (line 538) | def excessCagnoli_(a, b, c): function excessGirard_ (line 565) | def excessGirard_(A, B, C): function excessLHuilier_ (line 586) | def excessLHuilier_(a, b, c): function excessKarney (line 611) | def excessKarney(lat1, lon1, lat2, lon2, radius=R_M, wrap=False): function excessKarney_ (line 644) | def excessKarney_(phi2, phi1, lam21): function excessQuad (line 716) | def excessQuad(lat1, lon1, lat2, lon2, radius=R_M, wrap=False): function excessQuad_ (line 745) | def excessQuad_(phi2, phi1, lam21): function flatLocal (line 763) | def flatLocal(lat1, lon1, lat2, lon2, datum=_WGS84, scaled=True, wrap=Fa... function flatLocal_ (line 799) | def flatLocal_(phi2, phi1, lam21, datum=_WGS84, scaled=True): function flatPolar (line 830) | def flatPolar(lat1, lon1, lat2, lon2, radius=R_M, wrap=False): function flatPolar_ (line 855) | def flatPolar_(phi2, phi1, lam21): function _hartzell (line 883) | def _hartzell(pov, los, earth, **kwds): function hartzell (line 898) | def hartzell(pov, los=False, earth=_WGS84, **name_LatLon_and_kwds): function haversine (line 946) | def haversine(lat1, lon1, lat2, lon2, radius=R_M, wrap=False): function haversine_ (line 974) | def haversine_(phi2, phi1, lam21): function heightOf (line 993) | def heightOf(angle, distance, radius=R_M): function heightOrthometric (line 1027) | def heightOrthometric(h_loc, N): function horizon (line 1047) | def horizon(height, radius=R_M, refraction=False): class _idllmn6 (line 1072) | class _idllmn6(object): # see also .geodesicw._wargs, .latlonBase._toCa... method __call__ (line 1076) | def __call__(self, datum, lat1, lon1, lat2, lon2, small, wrap, s, **kw... function intersection2 (line 1114) | def intersection2(lat1, lon1, bearing1, function intersections2 (line 1181) | def intersections2(lat1, lon1, radius1, function isantipode (line 1249) | def isantipode(lat1, lon1, lat2, lon2, eps=EPS): function isantipode_ (line 1269) | def isantipode_(phi1, lam1, phi2, lam2, eps=EPS): function _isequalTo (line 1289) | def _isequalTo(p1, p2, eps=EPS): function _isequalTo_ (line 1296) | def _isequalTo_(p1, p2, eps=EPS): # underscore_! function isnormal (line 1303) | def isnormal(lat, lon, eps=0): function isnormal_ (line 1319) | def isnormal_(phi, lam, eps=0): function _maprod (line 1335) | def _maprod(fun_, *ts): function _normal2 (line 1341) | def _normal2(a, b, n_2, n, n2): function normal (line 1354) | def normal(lat, lon, **name): function normal_ (line 1370) | def normal_(phi, lam, **name): function _opposes (line 1386) | def _opposes(d, m, n, n2): function opposing (line 1394) | def opposing(bearing1, bearing2, margin=_90_0): function opposing_ (line 1410) | def opposing_(radians1, radians2, margin=PI_2): function _Propy (line 1426) | def _Propy(func, nargs, kwds): function _radical2 (line 1440) | def _radical2(d, r1, r2, **name): # in .ellipsoidalBaseDI, .sphericalTr... function radical2 (line 1448) | def radical2(distance, radius1, radius2, **name): class Radical2Tuple (line 1478) | class Radical2Tuple(_NamedTuple): function _radistance (line 1486) | def _radistance(inst): function _scale_deg (line 1513) | def _scale_deg(lat1, lat2): # degrees function _scale_rad (line 1519) | def _scale_rad(phi1, phi2): # radians, by .frechet, .hausdorff, .heights function _sincosa6 (line 1525) | def _sincosa6(phi2, phi1, lam21): # [4] in cosineLaw function thomas (line 1532) | def thomas(lat1, lon1, lat2, lon2, datum=_WGS84, wrap=False): function thomas_ (line 1556) | def thomas_(phi2, phi1, lam21, datum=_WGS84): function vincentys (line 1610) | def vincentys(lat1, lon1, lat2, lon2, radius=R_M, wrap=False): function vincentys_ (line 1639) | def vincentys_(phi2, phi1, lam21): FILE: pygeodesy/frechet.py function _fraction (line 109) | def _fraction(fraction, n): class FrechetError (line 121) | class FrechetError(PointsError): class Frechet (line 127) | class Frechet(_Named): method __init__ (line 139) | def __init__(self, point1s, fraction=None, units=NN, **name__kwds): method adjust (line 169) | def adjust(self): method datum (line 175) | def datum(self): method _datum_setter (line 180) | def _datum_setter(self, datum): method discrete (line 187) | def discrete(self, point2s, fraction=None, recursive=False): method _discrete (line 211) | def _discrete(self, point2s, fraction, distance, recursive): method distance (line 239) | def distance(self, point1, point2): method fraction (line 248) | def fraction(self): method fraction (line 254) | def fraction(self, fraction): method _func (line 268) | def _func(self): method _func (line 273) | def _func(self, func): method kwds (line 277) | def kwds(self): method point (line 282) | def point(self, point): method points_ (line 292) | def points_(self, points, i): method points_fraction (line 303) | def points_fraction(self, points, fi): method _points2 (line 314) | def _points2(self, points): method units (line 320) | def units(self): method units (line 326) | def units(self, units): method wrap (line 334) | def wrap(self): class FrechetDegrees (line 340) | class FrechetDegrees(Frechet): method distance (line 349) | def distance(self, point1, point2, *args, **kwds): # PYCHOK no cover class FrechetRadians (line 354) | class FrechetRadians(Frechet): method distance (line 363) | def distance(self, point1, point2, *args, **kwds): # PYCHOK no cover method point (line 367) | def point(self, point): class _FrechetMeterRadians (line 379) | class _FrechetMeterRadians(Frechet): method discrete (line 387) | def discrete(self, point2s, fraction=None, recursive=False): method _func_ (line 399) | def _func_(self): # see _formy._radistance method _func_ (line 404) | def _func_(self, func): class FrechetCosineLaw (line 408) | class FrechetCosineLaw(_FrechetMeterRadians): method __init__ (line 413) | def __init__(self, point1s, **fraction_name__corr_earth_wrap): class FrechetDistanceTo (line 431) | class FrechetDistanceTo(Frechet): # FrechetMeter method __init__ (line 436) | def __init__(self, point1s, **fraction_name__distanceTo_kwds): method distance (line 454) | def distance(self, p1, p2): method _points2 (line 459) | def _points2(self, points): class FrechetEquirectangular (line 466) | class FrechetEquirectangular(Frechet): method __init__ (line 471) | def __init__(self, point1s, **fraction_name__adjust_limit_wrap): class FrechetEuclidean (line 490) | class FrechetEuclidean(_FrechetMeterRadians): method __init__ (line 493) | def __init__(self, point1s, **fraction_name__adjust_radius_wrap): # w... class FrechetExact (line 511) | class FrechetExact(Frechet): method __init__ (line 516) | def __init__(self, point1s, datum=None, **fraction_name__wrap): class FrechetFlatLocal (line 539) | class FrechetFlatLocal(_FrechetMeterRadians): method __init__ (line 544) | def __init__(self, point1s, **fraction_name__datum_scaled_wrap): class FrechetFlatPolar (line 564) | class FrechetFlatPolar(_FrechetMeterRadians): method __init__ (line 567) | def __init__(self, point1s, **fraction_name__radius_wrap): class FrechetHaversine (line 585) | class FrechetHaversine(_FrechetMeterRadians): method __init__ (line 590) | def __init__(self, point1s, **fraction_name__radius_wrap): class FrechetHubeny (line 608) | class FrechetHubeny(FrechetFlatLocal): # for Karl Hubeny class FrechetKarney (line 616) | class FrechetKarney(Frechet): method __init__ (line 624) | def __init__(self, point1s, datum=None, **fraction_name__wrap): class FrechetThomas (line 650) | class FrechetThomas(_FrechetMeterRadians): method __init__ (line 653) | def __init__(self, point1s, **fraction_name__datum_wrap): class Frechet6Tuple (line 671) | class Frechet6Tuple(_NamedTuple): method toUnits (line 694) | def toUnits(self, **Error_name): # PYCHOK expected class FrechetVincentys (line 709) | class FrechetVincentys(_FrechetMeterRadians): method __init__ (line 714) | def __init__(self, point1s, **fraction_name__radius_wrap): function frechet_ (line 732) | def frechet_(point1s, point2s, distance=None, units=NN, recursive=False): function _frechet3 (line 781) | def _frechet3(r, t, s): # return tuple r if equal function _frechetDP (line 787) | def _frechetDP(ni, nj, dF, units, swap): function _frechetR (line 817) | def _frechetR(ni, fi, nj, fj, dF, units): # MCCABE 14 function _main (line 874) | def _main(): FILE: pygeodesy/fstats.py function _sampled (line 30) | def _sampled(n, sample): function _Xs (line 36) | def _Xs(**name_xs): class _FstatsNamed (line 48) | class _FstatsNamed(_Named): method __add__ (line 53) | def __add__(self, other): method __float__ (line 61) | def __float__(self): # PYCHOK no cover method __int__ (line 65) | def __int__(self): # PYCHOK no cover method __len__ (line 69) | def __len__(self): method __neg__ (line 74) | def __neg__(self): # PYCHOK no cover method __radd__ (line 78) | def __radd__(self, other): # PYCHOK no cover method __str__ (line 82) | def __str__(self): method copy (line 87) | def copy(self, deep=False, **name): class _FstatsBase (line 101) | class _FstatsBase(_FstatsNamed): method _copy (line 106) | def _copy(self, d, s): method fadd (line 114) | def fadd(self, xs, sample=False): # PYCHOK no cover method fadd_ (line 118) | def fadd_(self, *xs, **sample): method fmean (line 125) | def fmean(self, xs=None): method fmean_ (line 137) | def fmean_(self, *xs): method fstdev (line 144) | def fstdev(self, xs=None, **sample): method fstdev_ (line 158) | def fstdev_(self, *xs, **sample): method fvariance (line 165) | def fvariance(self, xs=None, **sample): method fvariance_ (line 179) | def fvariance_(self, *xs, **sample): method _iadd_other (line 186) | def _iadd_other(self, other): method _M1 (line 201) | def _M1(self): method _M2 (line 206) | def _M2(self): method _Mean (line 210) | def _Mean(self, xs=None): method _Stdev (line 217) | def _Stdev(self, xs=None, **sample): method _Variance (line 223) | def _Variance(self, xs=None, **sample): class Fcook (line 230) | class Fcook(_FstatsBase): method __init__ (line 239) | def __init__(self, xs=None, **name): method __iadd__ (line 254) | def __iadd__(self, other): method fadd (line 312) | def fadd(self, xs, sample=False): method fjb (line 364) | def fjb(self, xs=None, excess=True, sample=True): method fjb_ (line 380) | def fjb_(self, *xs, **sample_excess): method fkurtosis (line 388) | def fkurtosis(self, xs=None, excess=True, **sample): method fkurtosis_ (line 407) | def fkurtosis_(self, *xs, **excess_sample): method fmedian (line 414) | def fmedian(self, xs=None): method fmedian_ (line 429) | def fmedian_(self, *xs): method fskewness (line 436) | def fskewness(self, xs=None, **sample): method fskewness_ (line 454) | def fskewness_(self, *xs, **sample): method _JarqueBera (line 461) | def _JarqueBera(self, xs, excess, **sample): method _Kurtosis (line 471) | def _Kurtosis(self, n, excess, sample=False): method _Median (line 488) | def _Median(self, xs=None): method _Skewness (line 496) | def _Skewness(self, n, sample=False): method toFwelford (line 510) | def toFwelford(self, **name): class Fwelford (line 521) | class Fwelford(_FstatsBase): method __init__ (line 527) | def __init__(self, xs=None, **name): method __iadd__ (line 541) | def __iadd__(self, other): method fadd (line 590) | def fadd(self, xs, sample=False): class Flinear (line 620) | class Flinear(_FstatsNamed): method __init__ (line 625) | def __init__(self, xs=None, ys=None, Fstats=Fwelford, **name): method __iadd__ (line 650) | def __iadd__(self, other): method _copy (line 688) | def _copy(self, d, s): method _Correlation (line 698) | def _Correlation(self, **sample): method fadd (line 704) | def fadd(self, xs, ys, sample=False): method fadd_ (line 737) | def fadd_(self, *x_ys, **sample): method fcorrelation (line 750) | def fcorrelation(self, **sample): method fintercept (line 758) | def fintercept(self, **sample): method fslope (line 766) | def fslope(self, **sample): method _Intercept (line 774) | def _Intercept(self, **sample): method _Sampled (line 779) | def _Sampled(self, T, sample=False): method _Slope (line 785) | def _Slope(self, **sample): method x (line 791) | def x(self): method y (line 797) | def y(self): FILE: pygeodesy/fsums.py function _2finite (line 92) | def _2finite(x, _isfine=_isfinite): # in .fstats function _2float (line 99) | def _2float(index=None, _isfine=_isfinite, **name_x): # in .fmath, .fstats function _2products (line 113) | def _2products(x, ys, *zs): function _fma (line 136) | def _fma(*a_b_c): # PYCHOK no cover function _fma (line 154) | def _fma(a, b, c): # PYCHOK redef function _fmaX (line 161) | def _fmaX(r, *a_b_c): # PYCHOK no cover function _2products (line 175) | def _2products(x, y3s, *zs): # PYCHOK in _fma, ... function _2split3 (line 198) | def _2split3(x): function _2split3s (line 205) | def _2split3s(xs): # in Fsum.is_math_fma function f2product (line 209) | def f2product(two=None): function _Fsumf_ (line 228) | def _Fsumf_(*xs): # in .auxLat, ... function _Fsum1f_ (line 234) | def _Fsum1f_(*xs): # in .albers function _halfeven (line 240) | def _halfeven(s, r, p): function _isFsum (line 252) | def _isFsum(x): # in .fmath function _isFsum_2Tuple (line 258) | def _isFsum_2Tuple(x): # in .basics, .constants, .fmath, .fstats function _isOK (line 264) | def _isOK(unused): function _isOK_or_finite (line 270) | def _isOK_or_finite(x, _isfine=_isfinite): function _n_d2 (line 277) | def _n_d2(n, d): function _nfError (line 289) | def _nfError(x, *args): function _NonfiniteError (line 299) | def _NonfiniteError(x): function nonfiniterrors (line 306) | def nonfiniterrors(raiser=None): function _1primed (line 343) | def _1primed(xs, *ys): # in .fmath function _psum (line 355) | def _psum(ps, **_isfine): # PYCHOK used! function _Psum (line 379) | def _Psum(ps, **name_f2product_nonfinites_RESIDUAL): function _Psum_ (line 389) | def _Psum_(*ps, **name_f2product_nonfinites_RESIDUAL): function _residue (line 395) | def _residue(other): function _s_r2 (line 405) | def _s_r2(s, r): function _strcomplex (line 419) | def _strcomplex(s, *args): function _stresidual (line 428) | def _stresidual(prefix, residual, R=0, **mod_ratio): function _2sum (line 439) | def _2sum(a, b, _isfine=_isfinite): # in .testFmath function _threshold (line 463) | def _threshold(threshold=_0_0, **kwds): function _2tuple2 (line 475) | def _2tuple2(other): class Fsum (line 493) | class Fsum(_Named): # sync __methods__ with .vector3dBase.Vector3dBase,... method __init__ (line 529) | def __init__(self, *xs, **name_f2product_nonfinites_RESIDUAL): method __abs__ (line 548) | def __abs__(self): method __add__ (line 554) | def __add__(self, other): method __bool__ (line 566) | def __bool__(self): # PYCHOK Python 3+ method __call__ (line 572) | def __call__(self, other, **up): # in .fmath method __ceil__ (line 579) | def __ceil__(self): # PYCHOK not special in Python 2- method __cmp__ (line 588) | def __cmp__(self, other): # PYCHOK no cover method __divmod__ (line 598) | def __divmod__(self, other, **raiser_RESIDUAL): method __eq__ (line 616) | def __eq__(self, other): method __float__ (line 622) | def __float__(self): method __floor__ (line 629) | def __floor__(self): # PYCHOK not special in Python 2- method __floordiv__ (line 638) | def __floordiv__(self, other): method __ge__ (line 654) | def __ge__(self, other): method __gt__ (line 659) | def __gt__(self, other): method __hash__ (line 664) | def __hash__(self): # PYCHOK no cover method __iadd__ (line 671) | def __iadd__(self, other): method __ifloordiv__ (line 691) | def __ifloordiv__(self, other): method __imatmul__ (line 711) | def __imatmul__(self, other): # PYCHOK no cover method __imod__ (line 715) | def __imod__(self, other): method __imul__ (line 726) | def __imul__(self, other): method __int__ (line 741) | def __int__(self): method __invert__ (line 750) | def __invert__(self): # PYCHOK no cover method __ipow__ (line 755) | def __ipow__(self, other, *mod, **raiser_RESIDUAL): # PYCHOK 2 vs 3 args method __isub__ (line 793) | def __isub__(self, other): method __iter__ (line 812) | def __iter__(self): method __itruediv__ (line 817) | def __itruediv__(self, other, **raiser_RESIDUAL): method __le__ (line 842) | def __le__(self, other): method __len__ (line 847) | def __len__(self): method __lt__ (line 852) | def __lt__(self, other): method __matmul__ (line 857) | def __matmul__(self, other): # PYCHOK no cover method __mod__ (line 861) | def __mod__(self, other): method __mul__ (line 869) | def __mul__(self, other): method __ne__ (line 877) | def __ne__(self, other): method __neg__ (line 882) | def __neg__(self): method __pos__ (line 888) | def __pos__(self): method __pow__ (line 893) | def __pow__(self, other, *mod): # PYCHOK 2 vs 3 args method __radd__ (line 901) | def __radd__(self, other): method __rdivmod__ (line 909) | def __rdivmod__(self, other): method __rfloordiv__ (line 931) | def __rfloordiv__(self, other): method __rmatmul__ (line 939) | def __rmatmul__(self, other): # PYCHOK no cover method __rmod__ (line 943) | def __rmod__(self, other): method __rmul__ (line 951) | def __rmul__(self, other): method __round__ (line 959) | def __round__(self, *ndigits): # PYCHOK Python 3+ method __rpow__ (line 968) | def __rpow__(self, other, *mod): method __rsub__ (line 976) | def __rsub__(self, other): method __rtruediv__ (line 984) | def __rtruediv__(self, other, **raiser_RESIDUAL): method __str__ (line 997) | def __str__(self): method __sub__ (line 1002) | def __sub__(self, other): method __truediv__ (line 1014) | def __truediv__(self, other, **raiser_RESIDUAL): method as_integer_ratio (line 1041) | def as_integer_ratio(self): method as_iscalar (line 1061) | def as_iscalar(self): method ceil (line 1069) | def ceil(self): method _cmp_0 (line 1086) | def _cmp_0(self, other, op): method copy (line 1097) | def copy(self, deep=False, **name): method _copyd (line 1116) | def _copyd(self, which, name=NN): method _Error (line 1132) | def _Error(self, op, other, Error, **txt_cause): method _ErrorX (line 1139) | def _ErrorX(self, X, op, other, *mod): method _ErrorXs (line 1147) | def _ErrorXs(self, X, xs, **kwds): # in .fmath method _facc (line 1154) | def _facc(self, xs, up=True, **_X_x_origin): method _facc_args (line 1168) | def _facc_args(self, xs, **up): method _facc_dot (line 1175) | def _facc_dot(self, n, xs, ys, **kwds): # in .fmath method _facc_neg (line 1183) | def _facc_neg(self, xs, **up_origin): method _facc_power (line 1194) | def _facc_power(self, power, xs, which, **raiser_RESIDUAL): # in .fmath method _facc_scalar (line 1235) | def _facc_scalar(self, xs, **up): method _facc_scalar_ (line 1243) | def _facc_scalar_(self, *xs, **up): method _facc_xsum (line 1262) | def _facc_xsum(self, xs, up=True, **origin_which): method fadd (line 1270) | def fadd(self, xs=()): method fadd_ (line 1293) | def fadd_(self, *xs): method _fadd (line 1303) | def _fadd(self, other, op=_add_op_, **up): method _fdivmod2 (line 1316) | def _fdivmod2(self, other, op, **raiser_RESIDUAL): method _fhorner (line 1335) | def _fhorner(self, x, cs, where, incx=True): # in .fmath method _finite (line 1357) | def _finite(self, other, op=None): method fint (line 1365) | def fint(self, name=NN, **raiser_RESIDUAL): method fint2 (line 1389) | def fint2(self, **name): method _fint2 (line 1403) | def _fint2(self): # see ._fset method _fint2 (line 1417) | def _fint2(self, s): # in _fset method float_int (line 1429) | def float_int(self): # PYCHOK no cover method floor (line 1434) | def floor(self): method _floordiv (line 1452) | def _floordiv(self, other, op, **raiser_RESIDUAL): # rather _ffloordiv? method fma (line 1458) | def fma(self, other1, other2, **nonfinites): # in .fmath.fma method _fma (line 1470) | def _fma(self, other1, other2, **nonfinites): # in .elliptic method fma_ (line 1495) | def fma_(self, *xys, **nonfinites): method _fmul (line 1520) | def _fmul(self, other, op): method f2mul (line 1538) | def f2mul(self, *others, **raiser): method f2mul_ (line 1542) | def f2mul_(self, *others, **f2product_nonfinites): # in .fmath.f2mul method _f2mul (line 1558) | def _f2mul(self, where, others, f2product=True, **nonfinites_raiser): method fover (line 1585) | def fover(self, over, **raiser_RESIDUAL): method _fpow (line 1604) | def _fpow(self, other, op, *mod, **raiser_RESIDUAL): method f2product (line 1622) | def f2product(self, *two): method _fprs (line 1645) | def _fprs(self): method _fprs (line 1656) | def _fprs(self, s): method _fprs2 (line 1662) | def _fprs2(self): method _fprs2 (line 1698) | def _fprs2(self, s_r): method fset_ (line 1703) | def fset_(self, *xs): method _fset (line 1717) | def _fset(self, other, n=0, up=True, **op): method fsub (line 1747) | def fsub(self, xs=()): method fsub_ (line 1754) | def fsub_(self, *xs): method _fsub (line 1762) | def _fsub(self, other, op): method fsum (line 1774) | def fsum(self, xs=()): method fsum_ (line 1789) | def fsum_(self, *xs): method Fsum_ (line 1802) | def Fsum_(self, *xs, **name): method Fsum2Tuple_ (line 1811) | def Fsum2Tuple_(self, *xs, **name): method _Fsum (line 1821) | def _Fsum(self): # like L{Fsum2Tuple._Fsum}, in .fstats method _Fsum_as (line 1824) | def _Fsum_as(self, *xs, **name_f2product_nonfinites_RESIDUAL): method fsum2 (line 1840) | def fsum2(self, xs=(), **name): method fsum2_ (line 1859) | def fsum2_(self, *xs): method _fsum2 (line 1874) | def _fsum2(self, xs, _facc, **facc_kwds): method fsumf_ (line 1887) | def fsumf_(self, *xs): method Fsumf_ (line 1893) | def Fsumf_(self, *xs): method fsum2f_ (line 1899) | def fsum2f_(self, *xs): method _ftruediv (line 1907) | def _ftruediv(self, other, op, **raiser_RESIDUAL): method imag (line 1930) | def imag(self): method int_float (line 1937) | def int_float(self, **raiser_RESIDUAL): method is_exact (line 1965) | def is_exact(self): method is_finite (line 1971) | def is_finite(self): # in .constants method is_integer (line 1978) | def is_integer(self): method is_math_fma (line 1986) | def is_math_fma(self): method is_math_fsum (line 1995) | def is_math_fsum(self): method is_scalar (line 2004) | def is_scalar(self, **raiser_RESIDUAL): method _mul_Fsum (line 2025) | def _mul_Fsum(self, other, op): method _mul_reduce (line 2038) | def _mul_reduce(self, *others): method _mul_scalar (line 2046) | def _mul_scalar(self, factor, op): method _neg (line 2064) | def _neg(self): method _nfprs2 (line 2070) | def _nfprs2(self): method nonfinites (line 2079) | def nonfinites(self, *OK): method nonfinitesOK (line 2109) | def nonfinitesOK(self): method _nonfiniteX (line 2117) | def _nonfiniteX(self, X, op, f, nonfinites=None, raiser=None): method _optionals (line 2126) | def _optionals(self, f2product=None, nonfinites=None, **name_RESIDUAL): method _1_Over (line 2143) | def _1_Over(self, x, op, **raiser_RESIDUAL): # vs _1_over method partials (line 2149) | def partials(self): method pow (line 2154) | def pow(self, x, *mod, **raiser_RESIDUAL): method _pow (line 2180) | def _pow(self, other, unused, op, **raiser_RESIDUAL): method _pow_0_1 (line 2192) | def _pow_0_1(self, x, other): method _pow_2_3 (line 2197) | def _pow_2_3(self, b, x, other, op, *mod, **raiser_RESIDUAL): method _pow_Fsum (line 2226) | def _pow_Fsum(self, other, op, **raiser_RESIDUAL): method _pow_int (line 2236) | def _pow_int(self, x, other, op, **raiser_RESIDUAL): method _pow_scalar (line 2266) | def _pow_scalar(self, x, other, op, **raiser_RESIDUAL): method _ps_acc (line 2304) | def _ps_acc(self, ps, xs, up=True, **unused): # in .geoids._Dotf and ... method _ps_mul (line 2331) | def _ps_mul(self, op, *factors): method _ps_neg (line 2356) | def _ps_neg(self): method _ps_other (line 2362) | def _ps_other(self, op, other): method _ps_1sum (line 2371) | def _ps_1sum(self, *less): method _raiser (line 2376) | def _raiser(self, r, s, raiser=True, **RESIDUAL): method _rcopyd (line 2391) | def _rcopyd(self, other, which): method real (line 2400) | def real(self): method residual (line 2410) | def residual(self): method RESIDUAL (line 2421) | def RESIDUAL(self, *threshold): method _ResidualError (line 2451) | def _ResidualError(self, op, other, residual, **mod_R): method root (line 2461) | def root(self, root, **raiser_RESIDUAL): method _scalar (line 2480) | def _scalar(self, other, op, **txt): method signOf (line 2487) | def signOf(self, res=True): method toRepr (line 2499) | def toRepr(self, **lenc_prec_sep_fmt): # PYCHOK signature method toStr (line 2509) | def toStr(self, lenc=True, **prec_sep_fmt): # PYCHOK signature method _truediv (line 2526) | def _truediv(self, other, op, **raiser_RESIDUAL): method _update (line 2532) | def _update(self, updated=True): # see ._fset function _Float_Int (line 2552) | def _Float_Int(arg, **name_Error): class DivMod2Tuple (line 2559) | class DivMod2Tuple(_NamedTuple): class Fsum2Tuple (line 2570) | class Fsum2Tuple(_NamedTuple): # in .fstats method __abs__ (line 2581) | def __abs__(self): # in .fmath method __bool__ (line 2584) | def __bool__(self): # PYCHOK Python 3+ method __eq__ (line 2587) | def __eq__(self, other): method __float__ (line 2590) | def __float__(self): method __ge__ (line 2593) | def __ge__(self, other): method __gt__ (line 2596) | def __gt__(self, other): method __le__ (line 2599) | def __le__(self, other): method __lt__ (line 2602) | def __lt__(self, other): method __int__ (line 2605) | def __int__(self): method __ne__ (line 2608) | def __ne__(self, other): method __neg__ (line 2611) | def __neg__(self): method __pos__ (line 2616) | def __pos__(self): method as_integer_ratio (line 2619) | def as_integer_ratio(self): method _fint2 (line 2627) | def _fint2(self): method _fprs2 (line 2631) | def _fprs2(self): method _Fsum (line 2635) | def _Fsum(self): # this C{Fsum2Tuple} as L{Fsum}, in .fstats method Fsum_ (line 2640) | def Fsum_(self, *xs, **name_f2product_nonfinites_RESIDUAL): method is_exact (line 2645) | def is_exact(self): method is_finite (line 2650) | def is_finite(self): # in .constants method is_integer (line 2657) | def is_integer(self): method _mul_scalar (line 2662) | def _mul_scalar(self, other, op): # for Fsum._fmul method _n (line 2666) | def _n(self): method _other_op (line 2669) | def _other_op(self, other, which): method _ps (line 2674) | def _ps(self): method _ps_neg (line 2678) | def _ps_neg(self): method signOf (line 2681) | def signOf(self, **res): method toStr (line 2686) | def toStr(self, fmt=Fmt.g, **prec_sep): # PYCHOK signature class _Ksum (line 2698) | class _Ksum(Fsum): method __init__ (line 2703) | def __init__(self, s, t, *xs): method _s_t_n3 (line 2708) | def _s_t_n3(self): class ResidualError (line 2713) | class ResidualError(_ValueError): function _fsum (line 2736) | def _fsum(xs): # in .elliptic, .geoids function fsum (line 2743) | def fsum(xs, nonfinites=None, **floats): function fsum_ (line 2767) | def fsum_(*xs, **nonfinites): function fsumf_ (line 2778) | def fsumf_(*xs): function fsum1 (line 2789) | def fsum1(xs, **nonfinites): function fsum1_ (line 2800) | def fsum1_(*xs, **nonfinites): function fsum1f_ (line 2811) | def fsum1f_(*xs): function _x_isfine (line 2820) | def _x_isfine(nfOK, **kwds): # get the C{_x} and C{_isfine} handlers. function _X_ps (line 2827) | def _X_ps(X): # default C{_X} handler function _xs (line 2831) | def _xs(xs, _X=_X_ps, _x=float, _isfine=_isfinite, # defaults for Fsum.... function _xsum (line 2853) | def _xsum(which, xs, nonfinites=None, primed=0, **floats): # origin=0 function _test (line 2873) | def _test(n): FILE: pygeodesy/gars.py function _2divmod2 (line 57) | def _2divmod2(ll, _Orig_M4): function _2fll (line 64) | def _2fll(lat, lon, *unused): function _2garstr2 (line 83) | def _2garstr2(garef): function _2Precision (line 98) | def _2Precision(precision): class GARSError (line 104) | class GARSError(_ValueError): class Garef (line 110) | class Garef(Str): method __new__ (line 114) | def __new__(cls, lat_gll, lon=None, precision=1, **name): method decoded3 (line 158) | def decoded3(self): method _decoded3 (line 165) | def _decoded3(self): method latlon (line 171) | def latlon(self): method precision (line 178) | def precision(self): method toLatLon (line 184) | def toLatLon(self, LatLon=None, **LatLon_kwds): function decode3 (line 199) | def decode3(garef, center=True, **name): function encode (line 254) | def encode(lat, lon, precision=1): function _encode3 (line 276) | def _encode3(lat, lon, precision): # MCCABE 14 function precision (line 308) | def precision(res): function resolution (line 327) | def resolution(prec): FILE: pygeodesy/geod3solve.py class Geodesic3Error (line 34) | class Geodesic3Error(GeodesicError): class Geod3Solve8Tuple (line 40) | class Geod3Solve8Tuple(_GTuple): class _Geodesic3SolveBase (line 64) | class _Geodesic3SolveBase(_Solve3Base): method a (line 78) | def a(self): method b (line 84) | def b(self): method c (line 90) | def c(self): method _cmdBasic (line 96) | def _cmdBasic(self): method _e_option (line 104) | def _e_option(self): method Geod3Solve (line 111) | def Geod3Solve(self): method Geod3Solve (line 118) | def Geod3Solve(self, path): method _t_option (line 128) | def _t_option(self): method toStr (line 131) | def toStr(self, **prec_sep): # PYCHOK signature method _u_option (line 141) | def _u_option(self): class Geodesic3Solve (line 145) | class Geodesic3Solve(_Geodesic3SolveBase): method __init__ (line 157) | def __init__(self, triaxial3=_Triaxial3_WGS84, path=NN, **name): method _a12d (line 175) | def _a12d(self, r): method Direct (line 189) | def Direct(self, bet1, omg1, alp1, s12, outmask=_UNUSED_, **unit): # ... method DirectLine (line 196) | def DirectLine(self, bet1, omg1, alp1, caps=Caps.ALL, **unit_name): method Inverse (line 217) | def Inverse(self, bet1, omg1, bet2, omg2, outmask=_UNUSED_, **unit): ... method InverseLine (line 223) | def InverseLine(self, bet1, omg1, bet2, omg2, caps=Caps.ALL, **unit_na... method toStr (line 249) | def toStr(self, **prec_sep_other): # PYCHOK signature method triaxial3 (line 259) | def triaxial3(self): class GeodesicLine3Solve (line 265) | class GeodesicLine3Solve(_Geodesic3SolveBase): # _SolveGDictLineBase): method __init__ (line 280) | def __init__(self, geodesic3, bet1, omg1, alp1, caps=Caps.ALL, **unit_... method alp1 (line 320) | def alp1(self): method bet1 (line 336) | def bet1(self): method _cmdDistance (line 342) | def _cmdDistance(self): method geodesic3 (line 349) | def geodesic3(self): method Intersecant2 (line 354) | def Intersecant2(self, bet0, omg0, radius, **kwds): # PYCHOK no cover method omg1 (line 359) | def omg1(self): method PlumbTo (line 364) | def PlumbTo(self, bet0, omg0, **kwds): # PYCHOK no cover method Position (line 368) | def Position(self, s12, outmask=Caps.ALL): # PYCHOK usused method toStr (line 378) | def toStr(self, **prec_sep_other): # PYCHOK signature method triaxial3 (line 389) | def triaxial3(self): function _toAzi (line 395) | def _toAzi(alp): # as degrees function _toDegrees (line 399) | def _toDegrees(*angs, **unit_name): function _main (line 411) | def _main(): FILE: pygeodesy/geodesici.py class XDict (line 82) | class XDict(ADict): method __add__ (line 105) | def __add__(self, other): method __eq__ (line 110) | def __eq__(self, other): method __iadd__ (line 113) | def __iadd__(self, other): method __le__ (line 126) | def __le__(self, other): method __lt__ (line 130) | def __lt__(self, other): method __ne__ (line 136) | def __ne__(self, other): method _corners (line 140) | def _corners(self, sA, sB, T2): method _fixCoincident (line 148) | def _fixCoincident(self, X, c0=0): method _fixSegment (line 157) | def _fixSegment(self, sA, sB): # PYCHOK no cover method _is00 (line 192) | def _is00(self): method L1 (line 195) | def L1(self, other=None): method _nD1 (line 205) | def _nD1(self, D1): method _nD2 (line 212) | def _nD2(self, D2): method _nmD3 (line 220) | def _nmD3(self, n, m, D3): # d3 / 2 method _outSide (line 229) | def _outSide(self, sA, sB): method _skip (line 237) | def _skip(self, S_, T1_Delta): function XDict_ (line 244) | def XDict_(sA=_0_0, sB=_0_0, c=INT0, sX0=_0_0): class _IntersectBase (line 253) | class _IntersectBase(_NamedBase): method __init__ (line 258) | def __init__(self, geodesic, **name): method a (line 265) | def a(self): method All (line 272) | def All(self, glA, glB, **kwds): # PYCHOK no cover method _cHalf (line 277) | def _cHalf(self): # normalizer, semi-circumference method _cMax (line 281) | def _cMax(self): # outer circumference method datum (line 285) | def datum(self): method ellipsoid (line 291) | def ellipsoid(self): method f (line 297) | def f(self): method geodesic (line 305) | def geodesic(self): method _illz2G (line 310) | def _illz2G(self, G, il): method intersect7 (line 324) | def intersect7(self, start1, end1, start2, end2, X0=_X000, aMaX0=0, sM... method _Inversa12 (line 380) | def _Inversa12(self, A, B=None): method k2kAkB (line 386) | def k2kAkB(self, k): method Line (line 409) | def Line(self, lat1, lon1, azi1_lat2, *lon2, **name): # PYCHOK no cover method _ll3z4ll (line 413) | def _ll3z4ll(self, lat1, lon1, azi1_lat2, *lon2): method Next5s (line 422) | def Next5s(self, glA, glB, X0=_X000, aMax=1801, sMax=0, **unused): # ... method R (line 427) | def R(self): method _sMaX0_C2 (line 432) | def _sMaX0_C2(self, aMaX0=0, **sMaX0_C): method _xNext (line 444) | def _xNext(self, glA, glB, eps1, **eps_C): # PYCHOK no cover class Intersectool (line 454) | class Intersectool(_IntersectBase, _SolveCapsBase): method __init__ (line 477) | def __init__(self, a_geodesic=None, f=None, **name): method All (line 498) | def All(self, glA, glB, X0=_X000, eps1=_0_0, aMaX0=0, **sMaX0_C): # P... method _All2 (line 511) | def _All2(self, glA, glB, X0, eps1, **aMaX0_sMaX0_C): # MCCABE 13 method All5 (line 552) | def All5(self, glA, glB, X0=_X000, **aMaX0_sMaX0): method _cmdBasic (line 561) | def _cmdBasic(self): method Closest (line 568) | def Closest(self, glA, glB, X0=_X000, _C=False): method Closest5 (line 584) | def Closest5(self, glA, glB, **unused): method _GeodesicExact (line 593) | def _GeodesicExact(self): method _In5T (line 598) | def _In5T(self, glA, glB, S, X, k2=False, **_2X): method IntersectTool (line 612) | def IntersectTool(self): method IntersectTool (line 619) | def IntersectTool(self, path): method Line (line 628) | def Line(self, lat1, lon1, azi1_lat2, *lon2, **name): method Middle (line 643) | def Middle(self, glA, glB, **_C): method _middle5 (line 652) | def _middle5(self, glA, glB, _C=False, **unused): method Middle5 (line 676) | def Middle5(self, glA, glB, **unused): method Next (line 686) | def Next(self, glA, glB, eps1=None, **_C): # PYCHOK no cover method Next5 (line 699) | def Next5(self, glA, glB, **eps1): # PYCHOK no cover method _R_option (line 707) | def _R_option(self, _R=None): method Segment (line 712) | def Segment(self, glA, glB, **_C_unused): method Segment5 (line 728) | def Segment5(self, glA, glB, **unused): method toStr (line 736) | def toStr(self, prec=6, sep=_COMMASPACE_, **unused): # PYCHOK signature method _XDictInvoke (line 752) | def _XDictInvoke(self, alt, _k_sX0, args, _C=False, **_R): class Intersector (line 773) | class Intersector(_IntersectBase): method __init__ (line 783) | def __init__(self, geodesic, **name): method All (line 817) | def All(self, glA, glB, X0=None, aMaX0=0, **sMaX0_C): # MCCABE 15 method All5 (line 901) | def All5(self, glA, glB, X0=_X000, **aMaX0_sMaX0_C): method _Basic2 (line 912) | def _Basic2(self, glA, glB, S, i=0): method _C (line 925) | def _C(self, X, glA, glB, _C=False, _MM=False): method Closest (line 939) | def Closest(self, glA, glB, X0=_X000, **_C): method Closest5 (line 972) | def Closest5(self, glA, glB, X0=_X000): method _conjDist (line 983) | def _conjDist(self, gl, s, m12=0, M12=1, M21=1, semi=False): method _conjDist3s (line 1015) | def _conjDist3s(self): method _conjDist3 (line 1020) | def _conjDist3(self, gl): method _conjDist3Tt_ (line 1024) | def _conjDist3Tt_(self, c, X0=_X000): method _conjDist5 (line 1029) | def _conjDist5(self, azi): method Delta (line 1036) | def Delta(self): method _Delto (line 1041) | def _Delto(self, X): method _EPS3R (line 1047) | def _EPS3R(self): method _faPI_4 (line 1051) | def _faPI_4(self): method _GeodesicLine (line 1055) | def _GeodesicLine(self): method _In5T (line 1060) | def _In5T(self, glA, glB, S, X, k2=False, **_2X): method _Inverse (line 1071) | def _Inverse(self, A, B): # caps=Caps.STANDARD method Line (line 1074) | def Line(self, lat1, lon1, azi1_lat2, *lon2, **name): method _Line (line 1094) | def _Line(self, lat1=0, lon1=0, azi1=0): method Middle (line 1097) | def Middle(self, glA, glB, raiser=True, **_C): method _middle3 (line 1119) | def _middle3(self, glA, glB, raiser): # in .All, .Segment method Middle5 (line 1129) | def Middle5(self, glA, glB, raiser=True): method _m12_M12_M21 (line 1142) | def _m12_M12_M21(self, gl, s): method Next (line 1146) | def Next(self, glA, glB, eps1=None, **_C): # PYCHOK no cover method Next5 (line 1201) | def Next5(self, glA, glB, **eps1): # PYCHOK no cover method _obliqDist4 (line 1212) | def _obliqDist4(self): method _polarB3 (line 1235) | def _polarB3(self, lats=False): # PYCHOK no cover method _polarDist2 (line 1266) | def _polarDist2(self, lat1, lat2=False): method _Position (line 1273) | def _Position(self, gl, s): method Segment (line 1276) | def Segment(self, glA, glB, proven=None, raiser=True, **_C): method Segment5 (line 1328) | def Segment5(self, glA, glB, **proven_raiser): method _Spherical (line 1339) | def _Spherical(self, glA, glB, S): method _T2D1Delta (line 1379) | def _T2D1Delta(self): method _T2D2Delta (line 1383) | def _T2D2Delta(self): method _T2d3Delta (line 1386) | def _T2d3Delta(self, d3): method _Tol (line 1390) | def _Tol(self): # convergence tolerance method toStr (line 1393) | def toStr(self, **prec_sep_name): # PYCHOK signature method _xLines (line 1403) | def _xLines(self, glA, glB, s13=False): class Intersect7Tuple (line 1422) | class Intersect7Tuple(_NamedTuple): class Intersectool5Tuple (line 1435) | class Intersectool5Tuple(_NamedTuple): class Intersector5Tuple (line 1452) | class Intersector5Tuple(Intersectool5Tuple): class Middle5Tuple (line 1468) | class Middle5Tuple(Intersectool5Tuple): class _List (line 1480) | class _List(list): method __init__ (line 1484) | def __init__(self, Delta): method __contains__ (line 1488) | def __contains__(self, other): method addend (line 1497) | def addend(self, X, *d0_i): method sorter (line 1505) | def sorter(self, sMaX0, dot_C, glA, glB, **_C): function _L1 (line 1516) | def _L1(a, b): function _main (line 1529) | def _main(args): function _examples (line 1639) | def _examples(): FILE: pygeodesy/geodesicw.py class _gWrapped (line 48) | class _gWrapped(_kWrapped): method Geodesic (line 54) | def Geodesic(self): method GeodesicLine (line 291) | def GeodesicLine(self): method Geodesic_WGS84 (line 457) | def Geodesic_WGS84(self): class Geodesic (line 467) | class Geodesic(_gWrapped): # overwritten by 1st instance method __new__ (line 471) | def __new__(unused, a_ellipsoid=_EWGS84, f=None, **name): class GeodesicLine (line 487) | class GeodesicLine(_gWrapped): # overwritten by 1st instance method __new__ (line 491) | def __new__(unused, geodesic, lat1, lon1, azi1, caps=Caps.STANDARD_LIN... function Geodesic_WGS84 (line 511) | def Geodesic_WGS84(): class _wargs (line 519) | class _wargs(object): # see also .formy._idllmn6, .latlonBase._toCartes... method __call__ (line 523) | def __call__(self, inst, *args, **kwds): function _Intersecant2 (line 536) | def _Intersecant2(gl, lat0, lon0, radius, tol=_TOL, form=F_D): # MCCABE... function _PlumbTo (line 603) | def _PlumbTo(gl, lat0, lon0, est=None, tol=_TOL): FILE: pygeodesy/geodesicx/__main__.py function _main (line 11) | def _main(**C4order): # PYCHOK no cover FILE: pygeodesy/geodesicx/gx.py function _atan12 (line 88) | def _atan12(*sincos12, **sineg0): function _eTOL2 (line 94) | def _eTOL2(f): class _PDict (line 109) | class _PDict(GDict): method set_sigs (line 113) | def set_sigs(self, ssig1, csig1, ssig2, csig2): method toGDict (line 119) | def toGDict(self): # PYCHOK no cover class GeodesicExact (line 128) | class GeodesicExact(_GeodesicBase): method __init__ (line 137) | def __init__(self, a_ellipsoid=_EWGS84, f=None, caps=None, C4order=Non... method a (line 168) | def a(self): method ArcDirect (line 173) | def ArcDirect(self, lat1, lon1, azi1, a12, outmask=Caps.STANDARD): method ArcDirectLine (line 193) | def ArcDirectLine(self, lat1, lon1, azi1, a12, caps=Caps.ALL, **name): method Area (line 216) | def Area(self, polyline=False, **name): method b (line 235) | def b(self): method c2x (line 241) | def c2x(self): method C4f (line 253) | def C4f(self, eps): method _C4f_k2 (line 272) | def _C4f_k2(self, k2): # in ._GDictInverse and gxline._GeodesicLineEx... method C4order (line 278) | def C4order(self): method C4order (line 284) | def C4order(self, order): method C4Order (line 296) | def C4Order(self): method C4Order (line 302) | def C4Order(self, order): method _C4x (line 309) | def _C4x(self): method datum (line 328) | def datum(self): method Direct (line 333) | def Direct(self, lat1, lon1, azi1, s12=0, outmask=Caps.STANDARD): method Direct3 (line 353) | def Direct3(self, lat1, lon1, azi1, s12): # PYCHOK outmask method _DirectLine (line 362) | def _DirectLine(self, ll1, azi12, s12=0, **caps_name): method DirectLine (line 367) | def DirectLine(self, lat1, lon1, azi1, s12, caps=Caps.STANDARD, **name): method _dn (line 390) | def _dn(self, sbet, cbet): # in gxline._GeodesicLineExact.__init__ method e2 (line 400) | def e2(self): method _e2a2 (line 406) | def _e2a2(self): method _e2_f1 (line 412) | def _e2_f1(self): method _eF (line 418) | def _eF(self): method _eF_reset_cHe2_f1 (line 423) | def _eF_reset_cHe2_f1(self, x, y): method _eF_reset_k2 (line 433) | def _eF_reset_k2(self, x): method ellipsoid (line 443) | def ellipsoid(self): method ep2 (line 449) | def ep2(self): method _eTOL2 (line 457) | def _eTOL2(self): method flattening (line 463) | def flattening(self): method f1 (line 471) | def f1(self): # in .css.CassiniSoldner.reset method _f180 (line 477) | def _f180(self): method _GDictDirect (line 482) | def _GDictDirect(self, lat1, lon1, azi1, arcmode, s12_a12, outmask=Cap... method _GDictInverse (line 491) | def _GDictInverse(self, lat1, lon1, lat2, lon2, outmask=Caps.STANDARD)... method _GenDirect (line 707) | def _GenDirect(self, lat1, lon1, azi1, arcmode, s12_a12, outmask=Caps.... method _GenInverse (line 716) | def _GenInverse(self, lat1, lon1, lat2, lon2, outmask=Caps.STANDARD): method _Inverse (line 725) | def _Inverse(self, ll1, ll2, wrap, **outmask): method Inverse (line 732) | def Inverse(self, lat1, lon1, lat2, lon2, outmask=Caps.STANDARD): method Inverse1 (line 757) | def Inverse1(self, lat1, lon1, lat2, lon2, wrap=False): method Inverse3 (line 770) | def Inverse3(self, lat1, lon1, lat2, lon2): # PYCHOK outmask method _InverseLine (line 780) | def _InverseLine(self, ll1, ll2, wrap, **caps_name): method InverseLine (line 787) | def InverseLine(self, lat1, lon1, lat2, lon2, caps=Caps.STANDARD, **na... method _InverseArea (line 812) | def _InverseArea(self, _meridian, salp1, calp1, # PYCHOK 9 args method _InverseStart6 (line 862) | def _InverseStart6(self, lam12, p): method _Lambda6 (line 987) | def _Lambda6(self, salp1, calp1, diffp, p): method _Length5 (line 1059) | def _Length5(self, sig12, outmask, p): method Line (line 1099) | def Line(self, lat1, lon1, azi1, caps=Caps.ALL, **name): method n (line 1122) | def n(self): method _n_0_1 (line 1128) | def _n_0_1(self): method _n6PI (line 1134) | def _n6PI(self): method _Newton6 (line 1139) | def _Newton6(self, salp1, calp1, p): method toStr (line 1232) | def toStr(self, **prec_sep_name): # PYCHOK signature class GeodesicLineExact (line 1244) | class GeodesicLineExact(_GeodesicLineExact): method __init__ (line 1251) | def __init__(self, geodesic, lat1, lon1, azi1, caps=Caps.STANDARD, **n... function _Astroid (line 1274) | def _Astroid(x, y): function _C4coeffs (line 1328) | def _C4coeffs(nC4): # in .geodesicx.__main__ FILE: pygeodesy/geodesicx/gxarea.py class GeodesicAreaExact (line 38) | class GeodesicAreaExact(_NamedBase): method __init__ (line 57) | def __init__(self, geodesic, polyline=False, **name): method AddEdge (line 88) | def AddEdge(self, azi, s): method AddPoint (line 112) | def AddPoint(self, lat, lon): method area0x (line 140) | def area0x(self): method Compute (line 148) | def Compute(self, reverse=False, sign=True, polar=False): method _Direct (line 188) | def _Direct(self, azi, s): method ellipsoid (line 207) | def ellipsoid(self): method geodesic (line 213) | def geodesic(self): method _Inverse (line 220) | def _Inverse(self, lat1, lon1, lat2, lon2): method lat0 (line 235) | def lat0(self): method lat1 (line 241) | def lat1(self): method lon0 (line 247) | def lon0(self): method lon1 (line 253) | def lon1(self): method num (line 259) | def num(self): method polyline (line 265) | def polyline(self): method _print (line 270) | def _print(self, n, p, a, r, **kwds): # PYCHOK no cover method _reduced (line 279) | def _reduced(self, S12, xing, n, reverse=False, sign=True, polar=False): method Reset (line 300) | def Reset(self): method TestEdge (line 315) | def TestEdge(self, azi, s, **reverse_sign_polar): method TestPoint (line 342) | def TestPoint(self, lat, lon, **reverse_sign_polar): method toStr (line 369) | def toStr(self, prec=6, sep=_COMMASPACE_, **unused): # PYCHOK signature method verbose (line 385) | def verbose(self): method verbose (line 391) | def verbose(self, verbose): # PYCHOK no cover class PolygonArea (line 398) | class PolygonArea(GeodesicAreaExact): method __init__ (line 401) | def __init__(self, earth, polyline=False, **name): class _Accumulator (line 415) | class _Accumulator(_NamedBase): method __init__ (line 425) | def __init__(self, y=0, **name): method Add (line 436) | def Add(self, *ys): method Negate (line 458) | def Negate(self): method num (line 466) | def num(self): method Remainder (line 471) | def Remainder(self, y): method Reset (line 479) | def Reset(self, y=0): method _s_t (line 487) | def _s_t(self, s, t=0): method Sum (line 493) | def Sum(self, y=0): method Times (line 506) | def Times(self, y): method toStr (line 517) | def toStr(self, prec=6, sep=_COMMASPACE_, **unused): # PYCHOK signature function _s_t2 (line 531) | def _s_t2(y): FILE: pygeodesy/geodesicx/gxbases.py class _GeodesicBase (line 30) | class _GeodesicBase(_CapsBase): # in .geodsolve class _Gfloats (line 47) | class _Gfloats(dict): method __init__ (line 53) | def __init__(self, nC4): # PYCHOK signature method __call__ (line 56) | def __call__(self, fs): function _cosSeries (line 69) | def _cosSeries(c4s, sx, cx): # PYCHOK shared .geodesicx.gx and -.gxline function _f2 (line 106) | def _f2(hi, lo): # in .geodesicx._C4_24, _27 and _30 function _sincos12 (line 112) | def _sincos12(sin1, cos1, sin2, cos2, sineg0=False): function _sin1cos2 (line 130) | def _sin1cos2(sin1, cos1, sin2, cos2): function _sinf1cos2d (line 140) | def _sinf1cos2d(lat, f1): function _toNAN (line 150) | def _toNAN(outmask, *args): function _xnC4 (line 156) | def _xnC4(**name_nC4): FILE: pygeodesy/geodesicx/gxline.py function _update_glXs (line 66) | def _update_glXs(gX): # see GeodesicExact.C4order and -._ef_reset_k2 function _xGeodesicExact (line 77) | def _xGeodesicExact(**gX): class _GeodesicLineExact (line 83) | class _GeodesicLineExact(_GeodesicBase): method __init__ (line 100) | def __init__(self, gX, lat1, lon1, azi1, caps, **name_): method __del__ (line 153) | def __del__(self): # XXX use weakref? method _update (line 162) | def _update(self, updated, *attrs, **unused): method a1 (line 167) | def a1(self): method a13 (line 176) | def a13(self): method Arc (line 183) | def Arc(self): method ArcPosition (line 190) | def ArcPosition(self, a12, outmask=Caps.STANDARD): method azi0 (line 210) | def azi0(self): method azi0_sincos2 (line 219) | def azi0_sincos2(self): method azi1 (line 225) | def azi1(self): method azi1_sincos2 (line 231) | def azi1_sincos2(self): method _B41 (line 237) | def _B41(self): method _C4a (line 243) | def _C4a(self): method _caps_DISTANCE_IN (line 249) | def _caps_DISTANCE_IN(self): method _D0k2 (line 255) | def _D0k2(self): method _D1 (line 261) | def _D1(self): method Distance (line 266) | def Distance(self): method _E0b (line 274) | def _E0b(self): method _E1 (line 280) | def _E1(self): method _eF (line 286) | def _eF(self): method _GDictPosition (line 295) | def _GDictPosition(self, arcmode, s12_a12, outmask=Caps.STANDARD): # ... method _GenPosition (line 461) | def _GenPosition(self, arcmode, s12_a12, outmask): method _GenSet (line 470) | def _GenSet(self, debug, s12=None, a12=None, **llz2): method geodesic (line 490) | def geodesic(self): method Intersecant2 (line 496) | def Intersecant2(self, lat0, lon0, radius, tol=_TOL): method _H0e2_f1 (line 528) | def _H0e2_f1(self): method _H1 (line 534) | def _H1(self): method lat1 (line 540) | def lat1(self): method lon1 (line 546) | def lon1(self): method _lon1_norm180 (line 552) | def _lon1_norm180(self): method PlumbTo (line 557) | def PlumbTo(self, lat0, lon0, est=None, tol=_TOL): method Position (line 582) | def Position(self, s12, outmask=Caps.STANDARD): method s13 (line 604) | def s13(self): method SetArc (line 611) | def SetArc(self, a13): method SetDistance (line 625) | def SetDistance(self, s13): method _stau1_ctau1 (line 639) | def _stau1_ctau1(self): method _toProps7 (line 649) | def _toProps7(self): method toStr (line 655) | def toStr(self, **prec_sep_name): # PYCHOK signature FILE: pygeodesy/geodsolve.py class GeodSolve12Tuple (line 35) | class GeodSolve12Tuple(_GTuple): class _GeodesicSolveBase (line 48) | class _GeodesicSolveBase(_SolveGDictBase): method _b_option (line 58) | def _b_option(self): method _cmdBasic (line 62) | def _cmdBasic(self): method GeodSolve (line 72) | def GeodSolve(self): method GeodSolve (line 79) | def GeodSolve(self, path): method _u_option (line 89) | def _u_option(self): class GeodesicSolve (line 93) | class GeodesicSolve(_GeodesicSolveBase): method Area (line 105) | def Area(self, polyline=False, **name): method Direct3 (line 125) | def Direct3(self, lat1, lon1, azi1, s12): # PYCHOK outmask method _DirectLine (line 135) | def _DirectLine(self, ll1, azi12, **caps_name): # PYCHOK no cover method DirectLine (line 140) | def DirectLine(self, lat1, lon1, azi1, caps=Caps.ALL, **name): method _Inverse (line 164) | def _Inverse(self, ll1, ll2, wrap, **outmask): # PYCHOK no cover method Inverse3 (line 171) | def Inverse3(self, lat1, lon1, lat2, lon2): # PYCHOK outmask method _InverseLine (line 181) | def _InverseLine(self, ll1, ll2, wrap, **caps_name): # PYCHOK no cover method InverseLine (line 188) | def InverseLine(self, lat1, lon1, lat2, lon2, caps=Caps.ALL, **name): ... method toStr (line 213) | def toStr(self, **prec_sep_other): # PYCHOK signature class GeodesicLineSolve (line 223) | class GeodesicLineSolve(_GeodesicSolveBase, _SolveGDictLineBase): method __init__ (line 237) | def __init__(self, geodesic, lat1, lon1, azi1, caps=Caps.ALL, **name): method a13 (line 267) | def a13(self): method Arc (line 274) | def Arc(self): # PYCHOK no cover method ArcPosition (line 281) | def ArcPosition(self, a12, outmask=Caps.STANDARD): # PYCHOK no cover method azi1 (line 293) | def azi1(self): method azi1_sincos2 (line 301) | def azi1_sincos2(self): method _cmdArc (line 309) | def _cmdArc(self): method Distance (line 314) | def Distance(self): method geodesic (line 320) | def geodesic(self): method Intersecant2 (line 325) | def Intersecant2(self, lat0, lon0, radius, **kwds): # PYCHOK no cover method PlumbTo (line 329) | def PlumbTo(self, lat0, lon0, **kwds): # PYCHOK no cover method Position (line 333) | def Position(self, s12, outmask=Caps.STANDARD): method s13 (line 344) | def s13(self): method SetArc (line 351) | def SetArc(self, a13): # PYCHOK no cover method SetDistance (line 366) | def SetDistance(self, s13): # PYCHOK no cover method toStr (line 380) | def toStr(self, **prec_sep_other): # PYCHOK signature function _main (line 394) | def _main(): FILE: pygeodesy/geohash.py function _2bounds (line 47) | def _2bounds(LatLon, LatLon_kwds, s, w, n, e, **name): function _2center (line 59) | def _2center(bounds): function _2dab (line 66) | def _2dab(d, a, b): function _2fll (line 72) | def _2fll(lat, lon, *unused): function _2Geohash (line 80) | def _2Geohash(geohash): function _2latlon (line 87) | def _2latlon(s, w, n, e, fstr=None): function _2mid (line 96) | def _2mid(a, b): function _2mid_ndigits (line 102) | def _2mid_ndigits(a, b): # a > b function _2Precision (line 110) | def _2Precision(p): function _2res (line 116) | def _2res(res, **prec): class _GH (line 124) | class _GH(object): method _4d (line 127) | def _4d(self, s, w, n, e): # helper method Borders (line 132) | def Borders(self): method DecodeB32 (line 136) | def DecodeB32(self): # inverse EncodeB32 map method decode2 (line 139) | def decode2(self, geohash): method encode (line 148) | def encode(self, *lat_lon_prec_eps): method encode2 (line 181) | def encode2(self, lat, lon, prec, eps): method _LatLon2Tuple (line 192) | def _LatLon2Tuple(self): method Neighbors (line 202) | def Neighbors(self): method Sizes (line 209) | def Sizes(self): # height, width and radius (in meter) method swne4 (line 229) | def swne4(self, geohash, mask5=_MASK5): class Geohash (line 262) | class Geohash(Str): method __new__ (line 266) | def __new__(cls, lat_ghll, lon=None, precision=None, eps=EPS, **name): method ab (line 311) | def ab(self): method adjacent (line 315) | def adjacent(self, direction, **name): method _bounds (line 351) | def _bounds(self): method bounds (line 356) | def bounds(self, LatLon=None, **LatLon_kwds): method _distanceTo (line 373) | def _distanceTo(self, func_, other, **kwds): method distanceTo (line 379) | def distanceTo(self, other): method distance1To (line 400) | def distance1To(self, other): # PYCHOK no cover method distance2To (line 407) | def distance2To(self, other, radius=R_M, adjust=False, wrap=False): #... method distance3To (line 414) | def distance3To(self, other, radius=R_M, wrap=False): # PYCHOK no cover method equirectangularTo (line 420) | def equirectangularTo(self, other, radius=R_M, **adjust_limit_wrap): method euclideanTo (line 447) | def euclideanTo(self, other, **radius_adjust_wrap): method haversineTo (line 463) | def haversineTo(self, other, **radius_wrap): method latlon (line 480) | def latlon(self): method neighbors (line 488) | def neighbors(self): method philam (line 497) | def philam(self): method precision (line 504) | def precision(self): method resolution2 (line 510) | def resolution2(self): method sizes (line 517) | def sizes(self): method sizes3 (line 523) | def sizes3(self): method toLatLon (line 531) | def toLatLon(self, LatLon=None, **LatLon_kwds): method vincentysTo (line 547) | def vincentysTo(self, other, **radius_wrap): method E (line 564) | def E(self): method N (line 570) | def N(self): method NE (line 576) | def NE(self): method NW (line 582) | def NW(self): method S (line 588) | def S(self): method SE (line 594) | def SE(self): method SW (line 600) | def SW(self): method W (line 606) | def W(self): class Geohashed (line 612) | class Geohashed(object): method __init__ (line 617) | def __init__(self, precision, ndigits=None): method __len__ (line 635) | def __len__(self): method _ab2 (line 646) | def _ab2(self, *ll): # overwritten method _ab2float (line 651) | def _ab2float(self, *ll): method _ab2round (line 656) | def _ab2round(self, *ll): method clear (line 661) | def clear(self): method decoded (line 667) | def decoded(self, geohash, encoded=False): method encoded (line 686) | def encoded(self, lat, lon, decoded=False): method len2 (line 705) | def len2(self): method ndigits (line 712) | def ndigits(self): method precision (line 718) | def precision(self): class GeohashError (line 724) | class GeohashError(_ValueError): class Neighbors8Dict (line 730) | class Neighbors8Dict(_NamedDict): method __init__ (line 736) | def __init__(self, **kwds): # PYCHOK no *args class Resolutions2Tuple (line 745) | class Resolutions2Tuple(_NamedTuple): method lat (line 753) | def lat(self): method lon (line 759) | def lon(self): class Sizes3Tuple (line 765) | class Sizes3Tuple(_NamedTuple): function bounds (line 773) | def bounds(geohash, LatLon=None, **LatLon_kwds): function decode (line 795) | def decode(geohash): function decode2 (line 814) | def decode2(geohash, LatLon=None, **LatLon_kwds): function decode_error (line 839) | def decode_error(geohash): function decode_error2 (line 844) | def decode_error2(geohash): function distance_ (line 862) | def distance_(geohash1, geohash2): function distance1 (line 877) | def distance1(geohash1, geohash2): function distance2 (line 883) | def distance2(geohash1, geohash2): function distance3 (line 889) | def distance3(geohash1, geohash2): function encode (line 894) | def encode(lat, lon, precision=None, eps=EPS): function equirectangular4 (line 913) | def equirectangular4(geohash1, geohash2, radius=R_M): function euclidean_ (line 931) | def euclidean_(geohash1, geohash2, **radius_adjust_wrap): function haversine_ (line 948) | def haversine_(geohash1, geohash2, **radius_wrap): function neighbors (line 966) | def neighbors(geohash): function precision (line 981) | def precision(res1, res2=None): function resolution2 (line 1006) | def resolution2(prec1, prec2=None): function sizes (line 1031) | def sizes(geohash): function sizes3 (line 1037) | def sizes3(geohash): function vincentys_ (line 1049) | def vincentys_(geohash1, geohash2, **radius_wrap): function _t (line 1079) | def _t(prec=p): FILE: pygeodesy/geoids.py class _GKsum (line 149) | class _GKsum(Fsum): # for GeoidKarney only method __iadd__ (line 151) | def __iadd__(self, other): method __imul__ (line 156) | def __imul__(self, x): method fsum (line 162) | def fsum(self): # PYCHOK signature class _Dotf (line 165) | class _Dotf(_GKsum): # PYCHOK redef method __init__ (line 169) | def __init__(self, a, *b): class _Hornerf (line 172) | class _Hornerf(_GKsum): # PYCHOK redef method __init__ (line 176) | def __init__(self, x, *cs): # incx=True class GeoidError (line 183) | class GeoidError(HeightError): class _GeoidBase (line 189) | class _GeoidBase(_HeightBase): method __init__ (line 222) | def __init__(self, hs, p): method __call__ (line 267) | def __call__(self, *llis, **wrap_H): method __enter__ (line 299) | def __enter__(self): method __exit__ (line 304) | def __exit__(self, *unused): # PYCHOK exc_type, exc_value, exc_traceb... method __repr__ (line 310) | def __repr__(self): method __str__ (line 313) | def __str__(self): method _called (line 316) | def _called(self, llis, wrap=False, H=False): method _center (line 340) | def _center(self): method center (line 346) | def center(self, LatLon=None): method close (line 358) | def close(self): method closed (line 366) | def closed(self): method cropped (line 372) | def cropped(self): method dtype (line 378) | def dtype(self): method endian (line 385) | def endian(self): method _ev (line 391) | def _ev(self, y, x): # PYCHOK overwritten with .RectBivariateSpline.ev method _gaxis2 (line 395) | def _gaxis2(self, lo, d, n, name): method _g2ll2 (line 409) | def _g2ll2(self, lat, lon): # PYCHOK no cover method _gyx2g2 (line 413) | def _gyx2g2(self, y, x): method height (line 418) | def height(self, lats, lons, **wrap): method height_ (line 441) | def height_(self, *latlons, **wrap): method _heightOrthometric (line 456) | def _heightOrthometric(self): method _hGeoid (line 459) | def _hGeoid(self, lat, lon): method _highest (line 467) | def _highest(self): method highest (line 472) | def highest(self, LatLon=None, **unused): method hits (line 485) | def hits(self): method kind (line 491) | def kind(self): method knots (line 497) | def knots(self): method _ll2g2 (line 502) | def _ll2g2(self, lat, lon): # PYCHOK no cover method _LL3T (line 507) | def _LL3T(self): method _llh3 (line 512) | def _llh3(self, lat, lon): method _llh3LL (line 515) | def _llh3LL(self, llh, LatLon): method _llh3minmax (line 518) | def _llh3minmax(self, highest, *unused): method _load (line 526) | def _load(self, g, dtype=float, n=-1, offset=0, **sep): # sep=NN method _lowerleft (line 532) | def _lowerleft(self): method lowerleft (line 537) | def lowerleft(self, LatLon=None): method _loweright (line 550) | def _loweright(self): method loweright (line 555) | def loweright(self, LatLon=None): method _lowest (line 570) | def _lowest(self): method lowest (line 575) | def lowest(self, LatLon=None, **unused): method mean (line 588) | def mean(self): method name (line 596) | def name(self): method nBytes (line 602) | def nBytes(self): method _open (line 607) | def _open(self, geoid, datum, kind, name, smooth): method outside (line 626) | def outside(self, lat, lon): method pgm (line 640) | def pgm(self): method sizeB (line 646) | def sizeB(self): method smooth (line 652) | def smooth(self): method stdev (line 658) | def stdev(self): method _swne (line 665) | def _swne(self, crop): method toStr (line 685) | def toStr(self, prec=3, sep=_COMMASPACE_): # PYCHOK signature method u2B (line 709) | def u2B(self): method _upperleft (line 715) | def _upperleft(self): method upperleft (line 720) | def upperleft(self, LatLon=None): method _upperright (line 733) | def _upperright(self): method upperright (line 738) | def upperright(self, LatLon=None): class GeoidEGM96 (line 751) | class GeoidEGM96(_GeoidBase): method __init__ (line 761) | def __init__(self, EGM96_grd, datum=_WGS84, kind=3, smooth=0, **name_c... method _g2ll2 (line 816) | def _g2ll2(self, lat, lon): method _ll2g2 (line 820) | def _ll2g2(self, lat, lon): class GeoidG2012B (line 829) | class GeoidG2012B(_GeoidBase): method __init__ (line 848) | def __init__(self, g2012b_bin, datum=Datums.NAD83, kind=3, smooth=0, *... method _g2ll2 (line 920) | def _g2ll2(self, lat, lon): method _ll2g2 (line 924) | def _ll2g2(self, lat, lon): class GeoidHeight5Tuple (line 933) | class GeoidHeight5Tuple(_NamedTuple): # .geoids.py function _I (line 944) | def _I(i): function _T (line 951) | def _T(cs): class GeoidKarney (line 959) | class GeoidKarney(_GeoidBase): method __init__ (line 1049) | def __init__(self, egm_pgm, crop=None, datum=_WGS84, kind=3, **name_sm... method _c0c3v (line 1098) | def _c0c3v(self, y, x): method dtype (line 1129) | def dtype(self): method _ev (line 1134) | def _ev(self, lat, lon): # PYCHOK expected method _ev2k (line 1145) | def _ev2k(self, fy, fx, *yx): method _ev3k (line 1158) | def _ev3k(self, fy, fx, *yx): method _g2ll2 (line 1182) | def _g2ll2(self, lat, lon): method _g2yx2 (line 1186) | def _g2yx2(self, lat, lon): method _gyx2g2 (line 1192) | def _gyx2g2(self, y, x): method _highest_ltd (line 1198) | def _highest_ltd(self): method highest (line 1203) | def highest(self, LatLon=None, full=False): # PYCHOK full method _lat2y2 (line 1217) | def _lat2y2(self, lat2): method _ll2g2 (line 1225) | def _ll2g2(self, lat, lon): method _llh3minmax (line 1229) | def _llh3minmax(self, highest, *lat2): method _lowest_ltd (line 1253) | def _lowest_ltd(self): method lowest (line 1258) | def lowest(self, LatLon=None, full=False): # PYCHOK full method _raw (line 1272) | def _raw(self, y, x): method _raws (line 1292) | def _raws(self, y, x, ijs): method _raw2 (line 1296) | def _raw2(self, *lat2): method _seek (line 1309) | def _seek(self, y, x): class GeoidPGM (line 1319) | class GeoidPGM(_GeoidBase): method __init__ (line 1340) | def __init__(self, egm_pgm, crop=None, datum=_WGS84, kind=3, smooth=0,... method _g2ll2 (line 1414) | def _g2ll2(self, lat, lon): method _ll2g2 (line 1422) | def _ll2g2(self, lat, lon): class _Gpars (line 1435) | class _Gpars(_Named): method __repr__ (line 1454) | def __repr__(self): method __str__ (line 1460) | def __str__(self): class _PGM (line 1464) | class _PGM(_Gpars): method _llstr2floats (line 1492) | def _llstr2floats(latlon): method __init__ (line 1513) | def __init__(self, g, pgm=NN, itemsize=0, sizeB=0): # MCCABE 22 method _cropped (line 1590) | def _cropped(self, g, k1, south, west, north, east): # MCCABE 15 method _Errorf (line 1674) | def _Errorf(self, fmt, *args): # PYCHOK no cover method _lle2yx2 (line 1681) | def _lle2yx2(self, lat, lon, flon): method _tmpfile (line 1689) | def _tmpfile(self): method pgm (line 1702) | def pgm(self): class PGMError (line 1708) | class PGMError(GeoidError): function egmGeoidHeights (line 1714) | def egmGeoidHeights(GeoidHeights_dat): function _lonE2lon (line 1750) | def _lonE2lon(lon): function _lon2lonE (line 1758) | def _lon2lonE(lon): FILE: pygeodesy/hausdorff.py class HausdorffError (line 93) | class HausdorffError(PointsError): class Hausdorff (line 99) | class Hausdorff(_Named): method __init__ (line 110) | def __init__(self, point1s, seed=None, units=NN, **name__kwds): method adjust (line 140) | def adjust(self): method datum (line 146) | def datum(self): method _datum_setter (line 151) | def _datum_setter(self, datum): method directed (line 158) | def directed(self, point2s, early=True): method distance (line 175) | def distance(self, point1, point2): method _func (line 184) | def _func(self): method _func (line 189) | def _func(self, func): method _hausdorff_ (line 192) | def _hausdorff_(self, point2s, both, early, distance): method kwds (line 198) | def kwds(self): method point (line 203) | def point(self, point): method _points2 (line 208) | def _points2(self, points): method seed (line 214) | def seed(self): method seed (line 220) | def seed(self, seed): method symmetric (line 236) | def symmetric(self, point2s, early=True): method units (line 254) | def units(self): method units (line 260) | def units(self, units): method wrap (line 268) | def wrap(self): class HausdorffDegrees (line 274) | class HausdorffDegrees(Hausdorff): method distance (line 285) | def distance(self, point1, point2): # PYCHOK no cover class HausdorffRadians (line 290) | class HausdorffRadians(Hausdorff): method distance (line 301) | def distance(self, point1, point2): # PYCHOK no cover method point (line 305) | def point(self, point): class _HausdorffMeterRadians (line 317) | class _HausdorffMeterRadians(Hausdorff): method directed (line 325) | def directed(self, point2s, early=True): method symmetric (line 335) | def symmetric(self, point2s, early=True): method _func_ (line 346) | def _func_(self): # see _formy._radistance method _func_ (line 351) | def _func_(self, func): class HausdorffCosineLaw (line 355) | class HausdorffCosineLaw(_HausdorffMeterRadians): method __init__ (line 360) | def __init__(self, point1s, **seed_name__corr_earth_wrap): class HausdorffDistanceTo (line 379) | class HausdorffDistanceTo(Hausdorff): method __init__ (line 384) | def __init__(self, point1s, **seed_name__distanceTo_kwds): method distance (line 404) | def distance(self, p1, p2): method _points2 (line 409) | def _points2(self, points): class HausdorffEquirectangular (line 416) | class HausdorffEquirectangular(Hausdorff): method __init__ (line 421) | def __init__(self, point1s, **seed_name__adjust_limit_wrap): class HausdorffEuclidean (line 441) | class HausdorffEuclidean(_HausdorffMeterRadians): method __init__ (line 444) | def __init__(self, point1s, **seed_name__adjust_radius_wrap): class HausdorffExact (line 463) | class HausdorffExact(Hausdorff): method __init__ (line 468) | def __init__(self, point1s, datum=None, **seed_name__wrap): class HausdorffFlatLocal (line 492) | class HausdorffFlatLocal(_HausdorffMeterRadians): method __init__ (line 497) | def __init__(self, point1s, **seed_name__datum_scaled_wrap): class HausdorffFlatPolar (line 518) | class HausdorffFlatPolar(_HausdorffMeterRadians): method __init__ (line 523) | def __init__(self, points, **seed_name__radius_wrap): class HausdorffHaversine (line 542) | class HausdorffHaversine(_HausdorffMeterRadians): method __init__ (line 549) | def __init__(self, points, **seed_name__radius_wrap): class HausdorffHubeny (line 568) | class HausdorffHubeny(HausdorffFlatLocal): # for Karl Hubeny class HausdorffKarney (line 577) | class HausdorffKarney(Hausdorff): method __init__ (line 585) | def __init__(self, point1s, datum=None, **seed_name__wrap): class HausdorffThomas (line 608) | class HausdorffThomas(_HausdorffMeterRadians): method __init__ (line 611) | def __init__(self, point1s, **seed_name__datum_wrap): class HausdorffVincentys (line 630) | class HausdorffVincentys(_HausdorffMeterRadians): method __init__ (line 637) | def __init__(self, point1s, **seed_name__radius_wrap): function _hausdorff_ (line 656) | def _hausdorff_(ps1, ps2, both, early, seed, units, distance, point): function _point (line 699) | def _point(p): function hausdorff_ (line 710) | def hausdorff_(model, target, both=False, early=True, seed=None, units=NN, class Hausdorff6Tuple (line 746) | class Hausdorff6Tuple(_NamedTuple): method toUnits (line 767) | def toUnits(self, **Error_name): # PYCHOK expected function randomrangenerator (line 776) | def randomrangenerator(seed): FILE: pygeodesy/heights.py class HeightError (line 103) | class HeightError(PointsError): function _alist (line 109) | def _alist(ais): function _ascalar (line 114) | def _ascalar(ais): # in .geoids function _atuple (line 124) | def _atuple(ais): function _as_llis2 (line 129) | def _as_llis2(llis, m=1, Error=HeightError): # in .geoids function _InsufficientError (line 152) | def _InsufficientError(need, Error=HeightError, **name_value): # PYCHOK... function _orderedup (line 158) | def _orderedup(ts, lo=EPS, hi=PI2-EPS): function _xyhs (line 163) | def _xyhs(wrap=False, _lat=_90_0, _lon=_180_0, height=True, **name_lls): class _HeightNamed (line 179) | class _HeightNamed(_Named): # in .geoids method __call__ (line 190) | def __call__(self, *llis, **wrap): # PYCHOK no cover method _as_lls (line 208) | def _as_lls(self, lats, lons): # in .geoids method datum (line 222) | def datum(self): method height (line 227) | def height(self, lats, lons, **wrap): # PYCHOK no cover method height_ (line 231) | def height_(self, *latlons, **wrap): method kmin (line 246) | def kmin(self): method wrap (line 252) | def wrap(self): class _HeightBase (line 258) | class _HeightBase(_HeightNamed): # in .geoids method _as_xyllis4 (line 266) | def _as_xyllis4(self, llis, **wrap): method _ev (line 275) | def _ev(self, *args): # PYCHOK no cover method _evalls (line 279) | def _evalls(self, llis, **wrap): # XXX single arg, not *args method _ev2d (line 286) | def _ev2d(self, x, y): # PYCHOK no cover method _ev_name (line 291) | def _ev_name(self): method height (line 303) | def height(self, lats, lons, **wrap): method _interp2d (line 324) | def _interp2d(self, xs, ys, hs, kind=-3): method _kxky (line 348) | def _kxky(self, kind): method _np_sp2 (line 351) | def _np_sp2(self, throwarnings=False): # PYCHOK no cover method numpy (line 364) | def numpy(self): method scipy (line 370) | def scipy(self): method scipy_interpolate (line 376) | def scipy_interpolate(self): method _scipy_version (line 383) | def _scipy_version(self, **n): method _xyhs3 (line 388) | def _xyhs3(self, knots, wrap=False, **name): class HeightCubic (line 399) | class HeightCubic(_HeightBase): method __init__ (line 408) | def __init__(self, knots, **name_wrap): method __call__ (line 427) | def __call__(self, *llis, **wrap): method _ev (line 434) | def _ev(self, yis, xis): # PYCHOK overwritten with .RectBivariateSpli... class HeightLinear (line 440) | class HeightLinear(HeightCubic): method __init__ (line 449) | def __init__(self, knots, **name_wrap): class HeightLSQBiSpline (line 461) | class HeightLSQBiSpline(_HeightBase): method __init__ (line 468) | def __init__(self, knots, weight=None, low=1e-4, **name_wrap): method __call__ (line 521) | def __call__(self, *llis, **wrap): class HeightSmoothBiSpline (line 529) | class HeightSmoothBiSpline(_HeightBase): method __init__ (line 536) | def __init__(self, knots, s=4, **name_wrap): method __call__ (line 567) | def __call__(self, *llis, **wrap): class _HeightIDW (line 575) | class _HeightIDW(_HeightNamed): method __init__ (line 591) | def __init__(self, knots, beta=2, **name__kwds): method __call__ (line 613) | def __call__(self, *llis, **wrap): method adjust (line 640) | def adjust(self): method beta (line 646) | def beta(self): method beta (line 652) | def beta(self, beta): method datum (line 660) | def datum(self): method _datum_setter (line 665) | def _datum_setter(self, datum): method _distances (line 672) | def _distances(self, x, y): method _distancesTo (line 685) | def _distancesTo(self, _To): method height (line 695) | def height(self, lats, lons, **wrap): method _heights (line 714) | def _heights(self): method _hIDW (line 719) | def _hIDW(self, x, y): method hypot (line 730) | def hypot(self): method knots (line 736) | def knots(self): method kwds (line 742) | def kwds(self): method limit (line 748) | def limit(self): method radius (line 754) | def radius(self): method scaled (line 760) | def scaled(self): method wrap (line 766) | def wrap(self): class HeightIDWcosineLaw (line 772) | class HeightIDWcosineLaw(_HeightIDW): method __init__ (line 779) | def __init__(self, knots, beta=2, **name__corr_earth_datum_radius_wrap): class HeightIDWdistanceTo (line 796) | class HeightIDWdistanceTo(_HeightIDW): method __init__ (line 801) | def __init__(self, knots, beta=2, **name__distanceTo_kwds): method _distances (line 821) | def _distances(self, x, y): class HeightIDWequirectangular (line 836) | class HeightIDWequirectangular(_HeightIDW): method __init__ (line 841) | def __init__(self, knots, beta=2, **name__adjust_limit_wrap): # XXX b... method _distances (line 852) | def _distances(self, x, y): class HeightIDWeuclidean (line 867) | class HeightIDWeuclidean(_HeightIDW): method __init__ (line 872) | def __init__(self, knots, beta=2, **name__adjust_radius_wrap): class HeightIDWexact (line 889) | class HeightIDWexact(_HeightIDW): method __init__ (line 894) | def __init__(self, knots, beta=2, datum=None, **name__wrap): class HeightIDWflatLocal (line 917) | class HeightIDWflatLocal(_HeightIDW): method __init__ (line 922) | def __init__(self, knots, beta=2, **name__datum_hypot_scaled_wrap): class HeightIDWflatPolar (line 940) | class HeightIDWflatPolar(_HeightIDW): method __init__ (line 945) | def __init__(self, knots, beta=2, **name__radius_wrap): class HeightIDWhaversine (line 962) | class HeightIDWhaversine(_HeightIDW): method __init__ (line 969) | def __init__(self, knots, beta=2, **name__radius_wrap): class HeightIDWhubeny (line 986) | class HeightIDWhubeny(HeightIDWflatLocal): # for Karl Hubeny class HeightIDWkarney (line 994) | class HeightIDWkarney(_HeightIDW): method __init__ (line 1001) | def __init__(self, knots, beta=2, datum=None, **name__wrap): class HeightIDWthomas (line 1027) | class HeightIDWthomas(_HeightIDW): method __init__ (line 1032) | def __init__(self, knots, beta=2, **name__datum_wrap): class HeightIDWvincentys (line 1049) | class HeightIDWvincentys(_HeightIDW): method __init__ (line 1056) | def __init__(self, knots, beta=2, **name__radius_wrap): FILE: pygeodesy/internals.py function typename (line 27) | def typename(obj, *dflt): function _Property_RO (line 37) | def _Property_RO(method): class _Enum (line 59) | class _Enum(object): # in .elliptic, .utily method __init__ (line 64) | def __init__(self, **enums): method __str__ (line 69) | def __str__(self): class _MODS_Base (line 80) | class _MODS_Base(object): method __delattr__ (line 83) | def __delattr__(self, attr): # PYCHOK no cover method __setattr__ (line 86) | def __setattr__(self, attr, value): # PYCHOK no cover method basics (line 90) | def basics(self): method bits_machine2 (line 97) | def bits_machine2(self): # in test/bases.py method ctypes3 (line 114) | def ctypes3(self): method errors (line 126) | def errors(self): method inspect (line 133) | def inspect(self): # in .basics method ios_ver (line 139) | def ios_ver(self): method name (line 150) | def name(self): method nix2 (line 156) | def nix2(self): # PYCHOK no cover method nix_ver (line 172) | def nix_ver(self): # PYCHOK no cover method os (line 180) | def os(self): method osversion2 (line 188) | def osversion2(self): method _Popen_kwds2 (line 215) | def _Popen_kwds2(self): method Pythonarchine (line 226) | def Pythonarchine(self): method streprs (line 237) | def streprs(self): method sys_version_info2 (line 244) | def sys_version_info2(self): method version (line 250) | def version(self): function _caller3 (line 259) | def _caller3(up, base=True): # in .lazily, .named function _enquote (line 290) | def _enquote(strs, quote=_QUOTE2_, white=NN): # in .basics, .solveBase function _envPYGEODESY (line 301) | def _envPYGEODESY(which, dflt=NN): function _fper (line 307) | def _fper(p, q, per=_100_0, prec=1): function _headof (line 316) | def _headof(name): function _ImmutableError (line 323) | def _ImmutableError(*inst_attr_value): function _isAppleSi (line 335) | def _isAppleSi(): # PYCHOK no cover function _isiOS (line 341) | def _isiOS(): # in test/bases function _ismacOS (line 347) | def _ismacOS(): # in test/bases function _isNix (line 354) | def _isNix(): # in test/bases function _isPyChOK (line 360) | def _isPyChOK(): # PYCHOK no cover function _isPyPy (line 368) | def _isPyPy(): # in test/bases function _isWindows (line 375) | def _isWindows(): # in test/bases function _load_lib (line 382) | def _load_lib(name): function machine (line 410) | def machine(): function _name_version (line 421) | def _name_version(pkg): function _osversion2 (line 427) | def _osversion2(sep=NN): # in .lazily, test/bases.versions function _passarg (line 434) | def _passarg(arg): function _passargs (line 440) | def _passargs(*args): function _plural (line 446) | def _plural(noun, n, nn=NN): function _popen2 (line 452) | def _popen2(cmd, stdin=None): # in .mgrs, .solveBase, .testMgrs function _pregistry (line 462) | def _pregistry(registry): function print_ (line 469) | def print_(*args, **nl_nt_prec_prefix__end_file_flush_sep__kwds): # PYC... function printf (line 480) | def printf(fmt, *args, **nl_nt_prec_prefix__end_file_flush_sep__kwds): function _print7 (line 521) | def _print7(nl=0, nt=0, prec=6, prefix=NN, sep=_SPACE_, file=_sys.stdout, function _PYGEODESY_ENV (line 532) | def _PYGEODESY_ENV(which): function _Pythonarchine (line 538) | def _Pythonarchine(sep=NN): # in .lazily, test/bases versions function _secs2str (line 545) | def _secs2str(secs): # in .geoids, ../test/bases function _sizeof (line 564) | def _sizeof(obj, deep=True): function _sysctl_uint (line 609) | def _sysctl_uint(name): function _tailof (line 624) | def _tailof(name): function _under (line 631) | def _under(name): # PYCHOK in .datums, .auxilats, .geodesicw, .ups, .ut... function _usage (line 637) | def _usage(file_py, *args, **opts_help): # in .etm, .geodesici # PYCHO... function _usage_argv (line 665) | def _usage_argv(argv0, *args): function _version2 (line 679) | def _version2(version, n=2): function _version_info (line 688) | def _version_info(package): # in .basics, .karney._kWrapped.Math function _version_ints (line 698) | def _version_ints(vs): function _versions (line 711) | def _versions(sep=_SPACE_): function _main (line 723) | def _main(): FILE: pygeodesy/interns.py class _Dash (line 17) | class _Dash(str): method __call__ (line 20) | def __call__(self, *args): class _Int (line 26) | class _Int(int): class Str_ (line 32) | class Str_(str): method join_ (line 37) | def join_(self, *args): class _Prefix (line 52) | class _Prefix(Str_): method __call__ (line 55) | def __call__(self, *args): class _PyPy__ (line 61) | class _PyPy__(str): # overwritten by singleton below method __call__ (line 64) | def __call__(self, version=NN): class _Python_ (line 75) | class _Python_(str): # overwritten by singleton below method __call__ (line 78) | def __call__(self, version=NN): class _Range (line 85) | class _Range(str): method __call__ (line 88) | def __call__(self, lo, hi, lopen=False, ropen=False, class _Slicer (line 101) | class _Slicer(str): method __getattr__ (line 104) | def __getattr__(self, name): # .fromX, .tillY class MISSING (line 117) | class MISSING(object): method __init__ (line 120) | def __init__(self): method toRepr (line 123) | def toRepr(self, **unused): function _main (line 450) | def _main(globalocals): FILE: pygeodesy/iters.py class _BaseIter (line 36) | class _BaseIter(_Named): method __init__ (line 53) | def __init__(self, items, loop=0, dedup=False, Error=None, **name): method copies (line 91) | def copies(self): method dedup (line 100) | def dedup(self): method enumerate (line 105) | def enumerate(self, closed=False, copies=False, dedup=False): method __getitem__ (line 115) | def __getitem__(self, index): method __iter__ (line 130) | def __iter__(self): # PYCHOK no cover method iterate (line 136) | def iterate(self, closed=False, copies=False, dedup=False): method __len__ (line 174) | def __len__(self): method loop (line 180) | def loop(self): method looped (line 186) | def looped(self): method next (line 192) | def next(self): method next_ (line 200) | def next_(self, dedup=False): method _next (line 207) | def _next(self, dedup): method _next_dedup (line 227) | def _next_dedup(self): class PointsIter (line 238) | class PointsIter(_BaseIter): method __init__ (line 245) | def __init__(self, points, loop=0, base=None, dedup=False, wrap=False,... method enumerate (line 269) | def enumerate(self, closed=False, copies=False): # PYCHOK signature method iterate (line 283) | def iterate(self, closed=False, copies=False): # PYCHOK signature class LatLon2PsxyIter (line 311) | class LatLon2PsxyIter(PointsIter): method __init__ (line 319) | def __init__(self, points, loop=0, base=None, wrap=True, radius=None, method __getitem__ (line 349) | def __getitem__(self, index): method enumerate (line 360) | def enumerate(self, closed=False, copies=False): # PYCHOK signature method iterate (line 373) | def iterate(self, closed=False, copies=False): # PYCHOK signature method _point3Tuple (line 394) | def _point3Tuple(self, ll): function _imdex2 (line 405) | def _imdex2(closed, n): # PYCHOK by .clipy function isNumpy2 (line 411) | def isNumpy2(obj): function isPoints2 (line 423) | def isPoints2(obj): function isTuple2 (line 435) | def isTuple2(obj): function iterNumpy2 (line 447) | def iterNumpy2(obj): function iterNumpy2over (line 461) | def iterNumpy2over(n=None): function points2 (line 484) | def points2(points, closed=True, base=None, Error=PointsError): FILE: pygeodesy/karney.py class _GTuple (line 190) | class _GTuple(_NamedTuple): # in .testNamedTuples method _dup_iteration (line 193) | def _dup_iteration(self, r): method toGDict (line 198) | def toGDict(self, **updates): # NO name=NN method _toTuple (line 208) | def _toTuple(self, nTuple, dflt, updates={}): class _Lat (line 217) | class _Lat(Lat): method __init__ (line 220) | def __init__(self, *lat, **Error_name): class _Lon (line 225) | class _Lon(Lon): method __init__ (line 228) | def __init__(self, *lon, **Error_name): class Area3Tuple (line 233) | class Area3Tuple(_NamedTuple): # in .geodesicx.gxarea class Caps (line 242) | class Caps(object): method items (line 335) | def items(self): method toStr (line 343) | def toStr(self, Cask, sep=_BAR_): class _CapsBase (line 369) | class _CapsBase(_NamedBase): # in .auxilats, .geodesicx.gxbases method caps (line 393) | def caps(self): method caps_ (line 398) | def caps_(self, caps): method debug (line 411) | def debug(self): method debug (line 417) | def debug(self, debug): method _iter2tion (line 423) | def _iter2tion(self, r, iter=None, **unused): class Direct9Tuple (line 431) | class Direct9Tuple(_GTuple): class GDict (line 441) | class GDict(ADict): # XXX _NamedDict method toDirect9Tuple (line 447) | def toDirect9Tuple(self, dflt=NAN): method toGeodSolve12Tuple (line 458) | def toGeodSolve12Tuple(self, dflt=NAN): # PYCHOK 12 args method toGeod3Solve8Tuple (line 470) | def toGeod3Solve8Tuple(self, dflt=NAN): # PYCHOK 12 args method toInverse10Tuple (line 481) | def toInverse10Tuple(self, dflt=NAN): method _toNAN (line 492) | def _toNAN(self, outmask, **specs): # .GeodesicExact._GDistInverse, .... method toRhumb7Tuple (line 505) | def toRhumb7Tuple(self, dflt=NAN): # PYCHOK no cover method toRhumb8Tuple (line 512) | def toRhumb8Tuple(self, dflt=NAN): method toRhumbSolve7Tuple (line 522) | def toRhumbSolve7Tuple(self, dflt=NAN): method _toTuple (line 532) | def _toTuple(self, nTuple, dflt): method _2X (line 538) | def _2X(self, gl, _2X=_X_): # .Intersectool, .Intersector method _unCaps (line 550) | def _unCaps(self, outmask): # in .geodsolve class Inverse10Tuple (line 559) | class Inverse10Tuple(_GTuple): method toGDict (line 568) | def toGDict(self, **updates): class Rhumb8Tuple (line 578) | class Rhumb8Tuple(_GTuple): method toDirect9Tuple (line 587) | def toDirect9Tuple(self, dflt=NAN, **a12_azi1_azi2_m12_M12_M21): method toInverse10Tuple (line 604) | def toInverse10Tuple(self, dflt=NAN, **a12_m12_M12_M21_salp1_calp1_sal... method _to7Tuple (line 623) | def _to7Tuple(self): # in DEPRECATED Rhumb7Tuple class _kWrapped (line 628) | class _kWrapped(_CapsBase): # in .geodesicw method geographiclib (line 634) | def geographiclib(self): method Math (line 651) | def Math(self): method Math_K_2 (line 669) | def Math_K_2(self): method _PolygonArea (line 674) | def _PolygonArea(self): # lazy import class _Xables (line 681) | class _Xables(object): method GeoConvert (line 687) | def GeoConvert(self, *dir_): method GeodSolve (line 690) | def GeodSolve(self, *dir_): method Geod3Solve (line 693) | def Geod3Solve(self, *dir_): method IntersectTool (line 696) | def IntersectTool(self, *dir_): method RhumbSolve (line 699) | def RhumbSolve(self, *dir_): method name_version (line 702) | def name_version(self, path, base=True): method _path (line 717) | def _path(self, which, *dir_): method X_not (line 722) | def X_not(self, path): method X_OK (line 725) | def X_OK(self, path): # is C{path} an executable? function _around (line 732) | def _around(x): # in .utily.sincos2d function _atan2d (line 750) | def _atan2d(y, x): function _cbrt (line 759) | def _cbrt(x): function _copyBit (line 768) | def _copyBit(x, y): function _2cos2x (line 774) | def _2cos2x(cx, sx): # in .auxDST, .auxLat, .gxbases function _diff182 (line 783) | def _diff182(deg0, deg, K_2_0=False): function _fix90 (line 808) | def _fix90(deg): # mimick Math.LatFix function _isfinite (line 819) | def _isfinite(x): # mimick geomath.Math.isfinite function _llz2gl (line 830) | def _llz2gl(gl, **llz2): # see .geodesici._llz2G function _norm2 (line 841) | def _norm2(x, y): # mimick geomath.Math.norm function _norm180 (line 852) | def _norm180(deg): # mimick geomath.Math.AngNormalize function _polygon (line 866) | def _polygon(geodesic, points, closed, line, wrap, polar): function _poly_fma (line 909) | def _poly_fma(x, s, *cs): function _poly_fma (line 916) | def _poly_fma(x, *cs): # PYCHOK redef function _polynomial (line 925) | def _polynomial(x, cs, i, j): # PYCHOK shared function _remainder (line 941) | def _remainder(x, y): function _sincos2 (line 955) | def _sincos2(rad): function _signBit (line 962) | def _signBit(x): function _sincos2d (line 968) | def _sincos2d(deg): function _sincos2de (line 979) | def _sincos2de(deg, t): function _sum2 (line 990) | def _sum2(a, b): # mimick geomath.Math.sum, actually sum2 function _sum3 (line 1015) | def _sum3(s, t, *xs): function _tand (line 1033) | def _tand(x): function _unroll2 (line 1042) | def _unroll2(lon1, lon2, wrap=False): # see .ellipsoidalBaseDI._interse... function _unsigned2 (line 1057) | def _unsigned2(x): FILE: pygeodesy/ktm.py class KTMError (line 72) | class KTMError(_ValueError): class KTransverseMercator (line 78) | class KTransverseMercator(_NamedBase): method __init__ (line 117) | def __init__(self, a_earth=_EWGS84, f=None, lon0=0, k0=_K0_UTM, method _Alp (line 158) | def _Alp(self): method _b1 (line 162) | def _b1(self): method _Bet (line 174) | def _Bet(self): method datum (line 179) | def datum(self): method datum (line 185) | def datum(self, datum): method ellipsoid (line 194) | def ellipsoid(self): method ellipsoid (line 200) | def ellipsoid(self, a_earth_f): method equatoradius (line 207) | def equatoradius(self): method flattening (line 215) | def flattening(self): method forward (line 222) | def forward(self, lat, lon, lon0=None, **name): method k0 (line 281) | def k0(self): method k0 (line 287) | def k0(self, k0): method _k0_a1 (line 299) | def _k0_a1(self): method _k0_b1 (line 305) | def _k0_b1(self): method lon0 (line 311) | def lon0(self): method lon0 (line 317) | def lon0(self, lon0): method raiser (line 325) | def raiser(self): method raiser (line 331) | def raiser(self, raiser): method reset (line 337) | def reset(self, lat0, lon0): method reverse (line 353) | def reverse(self, x, y, lon0=None, **name): method TMorder (line 404) | def TMorder(self): method TMorder (line 410) | def TMorder(self, order): method toStr (line 418) | def toStr(self, **kwds): function _cfma (line 429) | def _cfma(a, b0, b1, Cn): function _Cyxgk4 (line 443) | def _Cyxgk4(E, xi_, eta_, C): function _sinhcosh2 (line 487) | def _sinhcosh2(x): function _Xs (line 493) | def _Xs(_Coeffs, m, E, RA=False): # in .rhumb.ekx FILE: pygeodesy/latlonBase.py class LatLonBase (line 56) | class LatLonBase(_NamedBase, _EcefLocal): method __init__ (line 65) | def __init__(self, lat_llh, lon=None, height=0, datum=None, **wrap_name): method __eq__ (line 107) | def __eq__(self, other): method __ne__ (line 110) | def __ne__(self, other): method __str__ (line 113) | def __str__(self): method antipode (line 116) | def antipode(self, height=None): method bounds (line 130) | def bounds(self, wide, tall, radius=R_M): # PYCHOK no cover method boundsOf (line 134) | def boundsOf(self, wide, tall, radius=R_M, height=None, **name): method chordTo (line 168) | def chordTo(self, other, height=None, wrap=False): method circin6 (line 191) | def circin6(self, point2, point3, eps=EPS4, **wrap_name): method circum3 (line 237) | def circum3(self, point2, point3, circum=True, eps=EPS4, **wrap_name): method circum4_ (line 284) | def circum4_(self, *points, **wrap_name): method clipid (line 320) | def clipid(self): method clipid (line 326) | def clipid(self, clipid): method compassAngle (line 332) | def compassAngle(self, other, **adjust_wrap): # PYCHOK no cover method compassAngleTo (line 336) | def compassAngleTo(self, other, **adjust_wrap): method cosineAndoyerLambertTo (line 361) | def cosineAndoyerLambertTo(self, other, **wrap): method cosineForsytheAndoyerLambertTo (line 366) | def cosineForsytheAndoyerLambertTo(self, other, **wrap): method cosineLawTo (line 370) | def cosineLawTo(self, other, **radius__corr_wrap): method datum (line 395) | def datum(self): # PYCHOK no cover method destinationXyz (line 399) | def destinationXyz(self, delta, LatLon=None, **LatLon_kwds): method _distanceTo (line 417) | def _distanceTo(self, func, other, radius=None, **kwds): method _distanceTo_ (line 424) | def _distanceTo_(self, func_, other, wrap=False, radius=None, **kwds): method _Ecef_forward (line 434) | def _Ecef_forward(self): method _ecef9 (line 440) | def _ecef9(self): method ellipsoidalLatLon (line 446) | def ellipsoidalLatLon(self): method equals (line 452) | def equals(self, other, eps=None): # PYCHOK no cover method equals3 (line 457) | def equals3(self, other, eps=None): # PYCHOK no cover method equirectangularTo (line 461) | def equirectangularTo(self, other, **radius_adjust_limit_wrap): method euclideanTo (line 486) | def euclideanTo(self, other, **radius_adjust_wrap): method flatLocalTo (line 507) | def flatLocalTo(self, other, radius=None, **wrap): method flatPolarTo (line 535) | def flatPolarTo(self, other, **radius_wrap): method hartzell (line 555) | def hartzell(self, los=False, earth=None): method haversineTo (line 579) | def haversineTo(self, other, **radius_wrap): method _havg (line 598) | def _havg(self, other, f=_0_5, h=None): method height (line 612) | def height(self): method height (line 618) | def height(self, height): method _heigHt (line 630) | def _heigHt(self, height): method height4 (line 635) | def height4(self, earth=None, normal=True, LatLon=None, **LatLon_kwds): method heightStr (line 676) | def heightStr(self, prec=-2, m=_m_): method intersecant2 (line 686) | def intersecant2(self, *args, **kwds): # PYCHOK no cover method _intersecend2 (line 690) | def _intersecend2(self, p, q, wrap, height, g_or_r, P, Q, unused): # ... method isantipode (line 717) | def isantipode(self, other, eps=EPS): # PYCHOK no cover method isantipodeTo (line 721) | def isantipodeTo(self, other, eps=EPS): method isEllipsoidal (line 735) | def isEllipsoidal(self): method isequalTo (line 740) | def isequalTo(self, other, eps=None): method isequalTo3 (line 758) | def isequalTo3(self, other, eps=None): method isnormal (line 776) | def isnormal(self): method isSpherical (line 786) | def isSpherical(self): method lam (line 792) | def lam(self): method lat (line 798) | def lat(self): method lat (line 804) | def lat(self, lat): method latlon (line 815) | def latlon(self): method latlon (line 821) | def latlon(self, latlonh): method latlon2 (line 850) | def latlon2(self, ndigits=0): method latlon_ (line 865) | def latlon_(self, ndigits=0): # PYCHOK no cover method latlonheight (line 872) | def latlonheight(self): method latlonheight (line 878) | def latlonheight(self, latlonh): method lon (line 888) | def lon(self): method lon (line 894) | def lon(self, lon): method nearestOn6 (line 906) | def nearestOn6(self, points, closed=False, height=None, wrap=False): method nearestTo (line 956) | def nearestTo(self, *args, **kwds): # PYCHOK no cover method normal (line 960) | def normal(self): method _N_vector (line 973) | def _N_vector(self): method _n_xyz3 (line 980) | def _n_xyz3(self): method phi (line 986) | def phi(self): method philam (line 992) | def philam(self): method philam2 (line 997) | def philam2(self, ndigits=0): method philamheight (line 1011) | def philamheight(self): method points (line 1017) | def points(self, points, **closed): # PYCHOK no cover method points2 (line 1021) | def points2(self, points, closed=True): method PointsIter (line 1037) | def PointsIter(self, points, loop=0, dedup=False, wrap=False): method radii11 (line 1053) | def radii11(self, point2, point3, wrap=False): method _rhumb3 (line 1076) | def _rhumb3(self, exact, radius): # != .sphericalBase._rhumbs3 method _rhumb3dict (line 1097) | def _rhumb3dict(self): # in ._update method rhumbAzimuthTo (line 1100) | def rhumbAzimuthTo(self, other, exact=False, radius=None, wrap=False, ... method rhumbDestination (line 1120) | def rhumbDestination(self, distance, azimuth, radius=None, height=None... method rhumbDistanceTo (line 1144) | def rhumbDistanceTo(self, other, exact=False, radius=None, wrap=False): method rhumbIntersecant2 (line 1162) | def rhumbIntersecant2(self, circle, point, other, height=None, method rhumbLine (line 1207) | def rhumbLine(self, other, exact=False, radius=None, wrap=False, **nam... method rhumbMidpointTo (line 1230) | def rhumbMidpointTo(self, other, exact=False, radius=None, height=None... method sphericalLatLon (line 1259) | def sphericalLatLon(self): method thomasTo (line 1264) | def thomasTo(self, other, **wrap): method to2ab (line 1283) | def to2ab(self): # PYCHOK no cover method toCartesian (line 1287) | def toCartesian(self, height=None, Cartesian=None, **Cartesian_kwds): method _toCartesianEcef (line 1312) | def _toCartesianEcef(self, height=None, i=None, up=2, **name_point): method toDatum (line 1328) | def toDatum(self, datum2, height=None, **name): method toEcef (line 1332) | def toEcef(self, height=None, M=False): method to3llh (line 1349) | def to3llh(self, height=None): # PYCHOK no cover method toNormal (line 1354) | def toNormal(self, deep=False, **name): method toNvector (line 1370) | def toNvector(self, h=None, Nvector=None, **name_Nvector_kwds): method toStr (line 1399) | def toStr(self, form=F_DMS, joined=_COMMASPACE_, m=_m_, **prec_sep_s_D... method toVector (line 1426) | def toVector(self, Vector=None, **Vector_kwds): method toVector3d (line 1444) | def toVector3d(self, norm=True, **Vector3d_kwds): method toWm (line 1462) | def toWm(self, **toWm_kwds): method to3xyz (line 1474) | def to3xyz(self): # PYCHOK no cover method vincentysTo (line 1486) | def vincentysTo(self, other, **radius_wrap): method _wrap_name2 (line 1505) | def _wrap_name2(self, wrap=False, **name): method xyz (line 1511) | def xyz(self): method xyz3 (line 1517) | def xyz3(self): method xyzh (line 1523) | def xyzh(self): class _toCartesian3 (line 1529) | class _toCartesian3(object): # see also .formy._idllmn6, .geodesicw._wa... method __call__ (line 1533) | def __call__(self, p, p2, p3, wrap, **kwds): function _latlonheight3 (line 1547) | def _latlonheight3(latlonh, height, wrap): # in .points.LatLon_.__init__ function latlon2n_xyz (line 1560) | def latlon2n_xyz(lat_ll, lon=None, **name): function philam2n_xyz (line 1586) | def philam2n_xyz(phi_ll, lam=None, **name): function _trilaterate5 (line 1609) | def _trilaterate5(p1, d1, p2, d2, p3, d3, area=True, eps=EPS1, radius=R_... FILE: pygeodesy/lazily.py class LazyAttributeError (line 61) | class LazyAttributeError(AttributeError): method __init__ (line 64) | def __init__(self, *args, **kwds): class LazyImportError (line 68) | class LazyImportError(ImportError): method __init__ (line 71) | def __init__(self, *args, **kwds): class _Dict (line 75) | class _Dict(dict): method __getattr__ (line 80) | def __getattr__(self, attr): method add (line 92) | def add(self, name, mod_, *subs): method _NAME (line 108) | def _NAME(self, which): class _NamedEnum_RO (line 112) | class _NamedEnum_RO(dict): method _DOT_ (line 117) | def _DOT_(self, attr): # PYCHOK no cover method __getattr__ (line 120) | def __getattr__(self, attr): method __setattr__ (line 127) | def __setattr__(self, attr, value): # PYCHOK no cover method enums (line 132) | def enums(self): method fill_D (line 145) | def fill_D(self, _D, which): function _a (line 160) | def _a(*names): function _ALL_ATTRS (line 166) | def _ALL_ATTRS(*attrs): class _ALL_MODS (line 434) | class _ALL_MODS(_internals._MODS_Base): method __getattr__ (line 437) | def __getattr__(self, name): method getattr (line 457) | def getattr(self, name, *attr_dflt): # , parent=_pygeodesy_ method getmodule (line 475) | def getmodule(self, name, parent=_pygeodesy_): method imported (line 491) | def imported(self, name): method into (line 496) | def into(self, **mod_DNAME): method items (line 518) | def items(self): # no module named 'items' method _triaxials_triaxial5 (line 526) | def _triaxials_triaxial5(self): function _ALL_OTHER (line 537) | def _ALL_OTHER(*objs): function _ALL_DOCS (line 556) | def _ALL_DOCS(*unused): function _all_deprecates (line 560) | def _all_deprecates(): function _all_enums (line 571) | def _all_enums(): function _all_imports (line 582) | def _all_imports(): function _all_missing2 (line 598) | def _all_missing2(_all_): function _getattras (line 610) | def _getattras(attr_as): # test/testDeprecated function _getmodattr (line 617) | def _getmodattr(m, name, mod=_pygeodesy_): function _getmodinto (line 628) | def _getmodinto(mod_DNAME, *Intos): function _getmodule (line 646) | def _getmodule(name, *parent): function _hash_imported (line 656) | def _hash_imported(t, by_into, up=3): function _lazy_import2 (line 687) | def _lazy_import2(pack): # MCCABE 14 function _lazy_import_as (line 785) | def _lazy_import_as(DUNDER_name): function _lazy_init2 (line 827) | def _lazy_init2(pack): function _lazy_module (line 872) | def _lazy_module(name): # overwritten by _lazy_import2 function _main (line 909) | def _main(): FILE: pygeodesy/lcc.py class Conic (line 62) | class Conic(_NamedEnumItem): method __init__ (line 86) | def __init__(self, latlon0, par1, par2=None, E0=0, N0=0, method auth (line 132) | def auth(self): method convertDatum (line 138) | def convertDatum(self, datum): method datum (line 143) | def datum(self): method E0 (line 149) | def E0(self): method k0 (line 155) | def k0(self): method lat0 (line 161) | def lat0(self): method latlon0 (line 167) | def latlon0(self): method lam0 (line 173) | def lam0(self): method lon0 (line 179) | def lon0(self): method N0 (line 185) | def N0(self): method name2 (line 191) | def name2(self): method opt3 (line 197) | def opt3(self): method par1 (line 203) | def par1(self): method par2 (line 209) | def par2(self): method phi0 (line 215) | def phi0(self): method philam0 (line 221) | def philam0(self): method SP (line 227) | def SP(self): method toDatum (line 232) | def toDatum(self, datum): method toStr (line 283) | def toStr(self, prec=8, **name): # PYCHOK expected method _dup2 (line 297) | def _dup2(self, c): method _mdef (line 324) | def _mdef(self, a): method _pdef (line 331) | def _pdef(self, a): method _rdef (line 337) | def _rdef(self, t): method _tdef (line 342) | def _tdef(self, a): method _xdef (line 347) | def _xdef(self, t_x): class Conics (line 356) | class Conics(_NamedEnum): method _Lazy (line 360) | def _Lazy(self, lat, lon, datum_name, *args, **kwds): class LCCError (line 389) | class LCCError(_ValueError): class Lcc (line 395) | class Lcc(_NamedBase): method __init__ (line 403) | def __init__(self, e, n, h=0, conic=Conics.WRF_Lb, **name): method conic (line 429) | def conic(self): method conic (line 435) | def conic(self, conic): method easting (line 463) | def easting(self): method height (line 469) | def height(self): method latlon (line 475) | def latlon(self): method latlonheight (line 482) | def latlonheight(self): method latlonheightdatum (line 488) | def latlonheightdatum(self): method northing (line 494) | def northing(self): method philam (line 500) | def philam(self): method philamheight (line 507) | def philamheight(self): method philamheightdatum (line 513) | def philamheightdatum(self): method to3lld (line 519) | def to3lld(self, datum=None): # PYCHOK no cover method toLatLon (line 538) | def toLatLon(self, LatLon=None, datum=None, height=None, **LatLon_kwds): method toRepr (line 582) | def toRepr(self, prec=0, fmt=Fmt.SQUARE, sep=_COMMASPACE_, m=_m_, C=Fa... method toStr (line 600) | def toStr(self, prec=0, sep=_SPACE_, m=_m_): # PYCHOK expected function toLcc (line 616) | def toLcc(latlon, conic=Conics.WRF_Lb, height=None, Lcc=Lcc, FILE: pygeodesy/ltp.py class Attitude (line 55) | class Attitude(_NamedBase): method __init__ (line 63) | def __init__(self, alt_attitude=INT0, tilt=INT0, yaw=INT0, roll=INT0, ... method alt (line 101) | def alt(self): method alt (line 105) | def alt(self, alt): # PYCHOK no cover method atyr (line 114) | def atyr(self): method matrix (line 120) | def matrix(self): method roll (line 135) | def roll(self): method roll (line 139) | def roll(self, roll): method rotate (line 147) | def rotate(self, x_xyz, y=None, z=None, Vector=None, **name_Vector_kwds): method tilt (line 185) | def tilt(self): method tilt (line 189) | def tilt(self, tilt): method toStr (line 197) | def toStr(self, prec=6, sep=_COMMASPACE_, **unused): # PYCHOK signature method tyr3d (line 210) | def tyr3d(self): method yaw (line 221) | def yaw(self): method yaw (line 225) | def yaw(self, yaw): class AttitudeError (line 234) | class AttitudeError(_ValueError): class Frustum (line 240) | class Frustum(_NamedBase): method __init__ (line 251) | def __init__(self, hfov, vfov, ltp=None, **name): method footprint5 (line 271) | def footprint5(self, alt_attitude, tilt=0, yaw=0, roll=0, z=_0_0, ltp=... method hfov (line 363) | def hfov(self): method ltp (line 369) | def ltp(self): method toStr (line 374) | def toStr(self, prec=3, fmt=Fmt.F, sep=_COMMASPACE_): # PYCHOK signature method vfov (line 390) | def vfov(self): class LocalError (line 396) | class LocalError(_ValueError): class LocalCartesian (line 402) | class LocalCartesian(_NamedBase): method __init__ (line 423) | def __init__(self, latlonh0=INT0, lon0=INT0, height0=INT0, ecef=None, ... method __eq__ (line 451) | def __eq__(self, other): method datum (line 463) | def datum(self): method ecef (line 469) | def ecef(self): method _ecef2local (line 474) | def _ecef2local(self, ecef, Xyz, name_Xyz_kwds): # in _EcefLocal._Ltp... method ellipsoid (line 504) | def ellipsoid(self): method forward (line 509) | def forward(self, latlonh, lon=None, height=0, M=False, **name): method height0 (line 543) | def height0(self): method lat0 (line 549) | def lat0(self): method latlonheight0 (line 555) | def latlonheight0(self): method _local2ecef (line 560) | def _local2ecef(self, local, nine=False, M=False): method lon0 (line 578) | def lon0(self): method lon00 (line 584) | def lon00(self): method lon00 (line 590) | def lon00(self, lon00): method M (line 597) | def M(self): method reset (line 602) | def reset(self, latlonh0=INT0, lon0=INT0, height0=INT0, ecef=None, **l... method reverse (line 628) | def reverse(self, xyz, y=None, z=None, M=False, **lon00_name): method _t0_xyz (line 663) | def _t0_xyz(self): method toStr (line 668) | def toStr(self, prec=9, **unused): # PYCHOK signature class Ltp (line 678) | class Ltp(LocalCartesian): method __init__ (line 684) | def __init__(self, latlonh0=INT0, lon0=INT0, height0=INT0, ecef=None, ... method ecef (line 700) | def ecef(self): method ecef (line 706) | def ecef(self, ecef): class _ChLV (line 717) | class _ChLV(object): method _ChLV9Tuple (line 724) | def _ChLV9Tuple(self, fw, M, name, *Y_X_h_lat_lon_h): method _enh_n_h (line 735) | def _enh_n_h(self): method forward (line 744) | def forward(self, latlonh, lon=None, height=0, M=None, **name): # PYC... method reverse (line 765) | def reverse(self, enh_, n=None, h_=0, M=None, **name): # PYCHOK no cover method _falsing2 (line 788) | def _falsing2(LV95): method _llh2abh_3 (line 795) | def _llh2abh_3(lat, lon, h): method _YXh_2abh3 (line 819) | def _YXh_2abh3(Y, X, h_): method _YXh_n4 (line 829) | def _YXh_n4(self, enh_, n, h_, **name): class ChLV (line 841) | class ChLV(_ChLV, Ltp): method __init__ (line 863) | def __init__(self, latlonh0=Bern, **other_Ltp_kwds): method forward (line 873) | def forward(self, latlonh, lon=None, height=0, M=None, **name): # PYC... method reverse (line 877) | def reverse(self, enh_, n=None, h_=0, M=None, **name): # PYCHOK signa... method false2 (line 883) | def false2(Y, X, LV95=True, **name): method isLV03 (line 901) | def isLV03(e, n): method isLV95 (line 915) | def isLV95(e, n, raiser=True): method unfalse2 (line 935) | def unfalse2(e, n, LV95=None, **name): class ChLVa (line 951) | class ChLVa(_ChLV, LocalCartesian): method __init__ (line 958) | def __init__(self, name=ChLV.Bern.name): method forward (line 965) | def forward(self, latlonh, lon=None, height=0, M=None, **name): method reverse (line 982) | def reverse(self, enh_, n=None, h_=0, M=None, **name): # PYCHOK signa... class ChLVe (line 1000) | class ChLVe(_ChLV, LocalCartesian): method __init__ (line 1016) | def __init__(self, name=ChLV.Bern.name): method forward (line 1023) | def forward(self, latlonh, lon=None, height=0, M=None, gamma=False, **... method reverse (line 1048) | def reverse(self, enh_, n=None, h_=0, M=None, gamma=False, **name): #... function _fov_2 (line 1075) | def _fov_2(**fov): function tyr3d (line 1084) | def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector... function _xLtp (line 1121) | def _xLtp(ltp, *dflt): FILE: pygeodesy/ltpTuples.py class _AbcBase (line 60) | class _AbcBase(_NamedBase): method ltp (line 66) | def ltp(self): method toAer (line 71) | def toAer(self, Aer=None, **name_Aer_kwds): method toEnu (line 86) | def toEnu(self, Enu=None, **name_Enu_kwds): method toNed (line 101) | def toNed(self, Ned=None, **name_Ned_kwds): method toXyz (line 116) | def toXyz(self, Xyz=None, **name_Xyz_kwds): method xyz (line 133) | def xyz(self): method xyz3 (line 139) | def xyz3(self): method xyz4 (line 145) | def xyz4(self): # PYCHOK no cover method xyzLocal (line 150) | def xyzLocal(self): class _Abc4Tuple (line 156) | class _Abc4Tuple(_NamedTuple): method _2Cls (line 160) | def _2Cls(self, Abc, Cls, Cls_kwds): method xyzLocal (line 186) | def xyzLocal(self): # PYCHOK no cover class Aer (line 191) | class Aer(_AbcBase): method __init__ (line 200) | def __init__(self, azimuth_aer, elevation=0, slantrange=0, ltp=None, *... method aer4 (line 234) | def aer4(self): method azimuth (line 240) | def azimuth(self): method down (line 246) | def down(self): method east (line 252) | def east(self): method elevation (line 258) | def elevation(self): method groundrange (line 264) | def groundrange(self): method north (line 270) | def north(self): method slantrange (line 276) | def slantrange(self): method toRepr (line 281) | def toRepr(self, prec=None, fmt=Fmt.SQUARE, sep=_COMMASPACE_, **unused... method toStr (line 297) | def toStr(self, **prec_fmt_sep): # PYCHOK expected method up (line 312) | def up(self): method x (line 318) | def x(self): method xyz4 (line 324) | def xyz4(self): method y (line 333) | def y(self): method z (line 339) | def z(self): class Aer4Tuple (line 345) | class Aer4Tuple(_Abc4Tuple): method _toAer (line 352) | def _toAer(self, Cls, Cls_kwds): method groundrange (line 358) | def groundrange(self): method xyzLocal (line 364) | def xyzLocal(self): class Attitude4Tuple (line 370) | class Attitude4Tuple(_NamedTuple): method atyr (line 379) | def atyr(self): method tyr3d (line 385) | def tyr3d(self): class Ned (line 391) | class Ned(_AbcBase): method __init__ (line 402) | def __init__(self, north_ned, east=0, down=0, ltp=None, **name): method aer4 (line 435) | def aer4(self): method azimuth (line 441) | def azimuth(self): method bearing (line 447) | def bearing(self): method down (line 452) | def down(self): method east (line 458) | def east(self): method elevation (line 464) | def elevation(self): method groundrange (line 470) | def groundrange(self): method length (line 476) | def length(self): method ned (line 481) | def ned(self): method ned4 (line 486) | def ned4(self): method north (line 492) | def north(self): method slantrange (line 498) | def slantrange(self): method to3ned (line 504) | def to3ned(self): # PYCHOK no cover method toRepr (line 508) | def toRepr(self, prec=None, fmt=Fmt.SQUARE, sep=_COMMASPACE_, **unused... method toStr (line 520) | def toStr(self, **prec_fmt_sep): # PYCHOK expected method toVector3d (line 535) | def toVector3d(self): method up (line 540) | def up(self): method x (line 546) | def x(self): method xyz4 (line 552) | def xyz4(self): method y (line 558) | def y(self): method z (line 564) | def z(self): class Ned4Tuple (line 570) | class Ned4Tuple(_Abc4Tuple): method _toNed (line 576) | def _toNed(self, Cls, Cls_kwds): method xyzLocal (line 582) | def xyzLocal(self): class _Vector3d (line 588) | class _Vector3d(Vector3d): method toRepr (line 592) | def toRepr(self, prec=None, fmt=Fmt.SQUARE, sep=_COMMASPACE_, **unused... method toStr (line 607) | def toStr(self, **prec_fmt_sep): # PYCHOK expected class XyzLocal (line 622) | class XyzLocal(_Vector3d): method __init__ (line 628) | def __init__(self, x_xyz, y=0, z=0, ltp=None, **name): method __str__ (line 659) | def __str__(self): method aer4 (line 663) | def aer4(self): method azimuth (line 669) | def azimuth(self): method classof (line 677) | def classof(self, *args, **kwds): # PYCHOK no cover method down (line 689) | def down(self): method ecef (line 695) | def ecef(self): method east (line 701) | def east(self): method elevation (line 707) | def elevation(self): method enu4 (line 716) | def enu4(self): method groundrange (line 722) | def groundrange(self): method ltp (line 728) | def ltp(self): method _ltp_kwds_name3 (line 733) | def _ltp_kwds_name3(self, ltp, kwds): method ned4 (line 742) | def ned4(self): method north (line 748) | def north(self): method slantrange (line 754) | def slantrange(self): method toAer (line 759) | def toAer(self, Aer=None, **name_Aer_kwds): method toCartesian (line 774) | def toCartesian(self, Cartesian=None, ltp=None, **name_Cartesian_kwds)... method toEnu (line 801) | def toEnu(self, Enu=None, **name_Enu_kwds): method toLatLon (line 816) | def toLatLon(self, LatLon=None, ltp=None, **name_LatLon_kwds): method toLocal9Tuple (line 841) | def toLocal9Tuple(self, M=False, **name): method toNed (line 857) | def toNed(self, Ned=None, **name_Ned_kwds): method toXyz (line 872) | def toXyz(self, Xyz=None, **name_Xyz_kwds): method up (line 889) | def up(self): method xyz4 (line 907) | def xyz4(self): method xyzLocal (line 913) | def xyzLocal(self): class Xyz4Tuple (line 931) | class Xyz4Tuple(_Abc4Tuple): method _toXyz (line 937) | def _toXyz(self, Cls, Cls_kwds): method xyz4 (line 943) | def xyz4(self): method xyzLocal (line 949) | def xyzLocal(self): class Enu (line 955) | class Enu(XyzLocal): method __init__ (line 963) | def __init__(self, east_enu, north=0, up=0, ltp=None, **name): method toUvw (line 985) | def toUvw(self, location, Uvw=None, **name_Uvw_kwds): method xyzLocal (line 1018) | def xyzLocal(self): class Enu4Tuple (line 1024) | class Enu4Tuple(_Abc4Tuple): method _toEnu (line 1030) | def _toEnu(self, Cls, Cls_kwds): method xyzLocal (line 1036) | def xyzLocal(self): class Local9Tuple (line 1042) | class Local9Tuple(_NamedTuple): method azimuth (line 1053) | def azimuth(self): method down (line 1059) | def down(self): method east (line 1065) | def east(self): method elevation (line 1071) | def elevation(self): method groundrange (line 1077) | def groundrange(self): method lam (line 1083) | def lam(self): method latlon (line 1089) | def latlon(self): method latlonheight (line 1095) | def latlonheight(self): method north (line 1101) | def north(self): method phi (line 1107) | def phi(self): method philam (line 1113) | def philam(self): method philamheight (line 1119) | def philamheight(self): method slantrange (line 1125) | def slantrange(self): method toAer (line 1130) | def toAer(self, Aer=None, **name_Aer_kwds): method toCartesian (line 1145) | def toCartesian(self, Cartesian=None, **name_Cartesian_kwds): method toEnu (line 1161) | def toEnu(self, Enu=None, **name_Enu_kwds): method toLatLon (line 1176) | def toLatLon(self, LatLon=None, **name_LatLon_kwds): method toNed (line 1194) | def toNed(self, Ned=None, **name_Ned_kwds): method toXyz (line 1209) | def toXyz(self, Xyz=None, **name_Xyz_kwds): method up (line 1225) | def up(self): method xyz (line 1231) | def xyz(self): method xyzLocal (line 1237) | def xyzLocal(self): class Uvw (line 1247) | class Uvw(_Vector3d): method __init__ (line 1252) | def __init__(self, u_uvw, v=0, w=0, **name): method toEnu (line 1269) | def toEnu(self, location, Enu=Enu, **name_Enu_kwds): method uvw (line 1304) | def uvw(self): class Uvw3Tuple (line 1313) | class Uvw3Tuple(_NamedTuple): class Los (line 1320) | class Los(Aer): method __init__ (line 1324) | def __init__(self, azimuth_aer, elevation=0, **name): method toUvw (line 1342) | def toUvw(self, location, Uvw=Uvw, **name_Uvw_kwds): method toEnu (line 1352) | def toEnu(self, Enu=Enu, **name_Enu_kwds): class ChLV9Tuple (line 1360) | class ChLV9Tuple(Local9Tuple): method E_LV95 (line 1369) | def E_LV95(self): method EN2_LV95 (line 1375) | def EN2_LV95(self): method h_LV03 (line 1381) | def h_LV03(self): method h_LV95 (line 1387) | def h_LV95(self): method isChLV (line 1393) | def isChLV(self): method isChLVa (line 1399) | def isChLVa(self): method isChLVe (line 1405) | def isChLVe(self): method N_LV95 (line 1411) | def N_LV95(self): method x (line 1417) | def x(self): method x_LV03 (line 1423) | def x_LV03(self): method y (line 1429) | def y(self): method y_LV03 (line 1435) | def y_LV03(self): method YX (line 1441) | def YX(self): method yx2_LV03 (line 1447) | def yx2_LV03(self): method z (line 1453) | def z(self): class ChLVYX2Tuple (line 1459) | class ChLVYX2Tuple(_NamedTuple): method false2 (line 1466) | def false2(self, LV95=True): class ChLVEN2Tuple (line 1474) | class ChLVEN2Tuple(_NamedTuple): method unfalse2 (line 1481) | def unfalse2(self): class ChLVyx2Tuple (line 1489) | class ChLVyx2Tuple(_NamedTuple): method unfalse2 (line 1496) | def unfalse2(self): class Footprint5Tuple (line 1504) | class Footprint5Tuple(_NamedTuple): method toLatLon5 (line 1514) | def toLatLon5(self, ltp=None, LatLon=None, **name_LatLon_kwds): method xyzLocal5 (line 1539) | def xyzLocal5(self, ltp=None): function _ChLV_false2 (line 1557) | def _ChLV_false2(Y, X, **LV95_name): function _ChLV_unfalse2 (line 1563) | def _ChLV_unfalse2(e, n, **LV95_name): function _er2gr (line 1569) | def _er2gr(e, r): function _init (line 1576) | def _init(inst, abc, ltp, name): function _toStr2 (line 1590) | def _toStr2(inst, prec=None, fmt=Fmt.SQUARE, sep=_COMMASPACE_): function _xyz2aer4 (line 1603) | def _xyz2aer4(inst): function _xyzLocal (line 1613) | def _xyzLocal(*Types, **name_inst): FILE: pygeodesy/mgrs.py class Mgrs (line 77) | class Mgrs(_NamedBase): method __init__ (line 90) | def __init__(self, zone=0, EN=NN, easting=0, northing=0, band=NN, method __str__ (line 138) | def __str__(self): method band (line 142) | def band(self): method bandLatitude (line 149) | def bandLatitude(self): method datum (line 155) | def datum(self): method digraph (line 161) | def digraph(self): method EN (line 166) | def EN(self): method en100k (line 172) | def en100k(self): method _EN2m (line 177) | def _EN2m(self): method easting (line 200) | def easting(self): method eastingnorthing (line 206) | def eastingnorthing(self): method isUPS (line 213) | def isUPS(self): method isUTM (line 219) | def isUTM(self): method northing (line 225) | def northing(self): method northingBottom (line 231) | def northingBottom(self): method parse (line 239) | def parse(self, strMGRS, **name): method resolution (line 253) | def resolution(self): method resolution (line 260) | def resolution(self, resolution): method tilesize (line 275) | def tilesize(self): method toLatLon (line 281) | def toLatLon(self, LatLon=None, center=True, **toLatLon_kwds): method toRepr (line 304) | def toRepr(self, fmt=Fmt.SQUARE, sep=_COMMASPACE_, **prec): # PYCHOK ... method toStr (line 322) | def toStr(self, prec=0, sep=NN): # PYCHOK expected method toUps (line 344) | def toUps(self, Ups=Ups, center=False): method toUtm (line 362) | def toUtm(self, Utm=Utm, center=False): method toUtmUps (line 380) | def toUtmUps(self, Utm=Utm, Ups=Ups, center=False): method _toUtmUps (line 397) | def _toUtmUps(self, U, center): method zone (line 425) | def zone(self): method zoneB (line 431) | def zoneB(self): class Mgrs4Tuple (line 438) | class Mgrs4Tuple(_NamedTuple): method digraph (line 450) | def digraph(self): method toMgrs (line 454) | def toMgrs(self, **Mgrs_and_kwds): method to6Tuple (line 459) | def to6Tuple(self, band=NN, datum=_WGS84): class Mgrs6Tuple (line 479) | class Mgrs6Tuple(_NamedTuple): # XXX only used above method digraph (line 492) | def digraph(self): method toMgrs (line 496) | def toMgrs(self, Mgrs=Mgrs, **Mgrs_kwds): class _RE (line 507) | class _RE(object): method pB_EN (line 516) | def pB_EN(self): # split polar "BEN" into 2 parts method pB_EN_en (line 521) | def pB_EN_en(self): # split polar "BEN1235..." into 3 parts method zB_EN (line 526) | def zB_EN(self): # split "1[2]BEN" into 2 parts method zB_EN_en (line 531) | def zB_EN_en(self): # split "1[2]BEN1235..." into 3 parts function parseMGRS (line 538) | def parseMGRS(strMGRS, datum=_WGS84, Mgrs=Mgrs, **name): function toMgrs (line 594) | def toMgrs(utmups, Mgrs=Mgrs, **name_Mgrs_kwds): function _um100km2 (line 644) | def _um100km2(m): function _main (line 655) | def _main(): FILE: pygeodesy/named.py class ADict (line 54) | class ADict(dict): method __getattr__ (line 60) | def __getattr__(self, name): method __repr__ (line 70) | def __repr__(self): method __setattr__ (line 75) | def __setattr__(self, name, value): method __str__ (line 84) | def __str__(self): method _AttributeError (line 89) | def _AttributeError(self, name): method iteration (line 97) | def iteration(self): # see .named._NamedBase method set_ (line 103) | def set_(self, iteration=None, **items): # PYCHOK signature method _toL (line 115) | def _toL(self): method toRepr (line 120) | def toRepr(self, **prec_fmt): method toStr (line 127) | def toStr(self, **prec_fmt): method _toT (line 133) | def _toT(self, sep, **kwds): method typename (line 140) | def typename(self): class _Named (line 146) | class _Named(object): method __format__ (line 154) | def __format__(self, fmt): # PYCHOK no cover method __imatmul__ (line 158) | def __imatmul__(self, other): # PYCHOK no cover method __matmul__ (line 162) | def __matmul__(self, other): # PYCHOK no cover method __repr__ (line 166) | def __repr__(self): method __rmatmul__ (line 171) | def __rmatmul__(self, other): # PYCHOK no cover method __str__ (line 175) | def __str__(self): method attrs (line 180) | def attrs(self, *names, **sep_Nones_pairs_kwds): method classname (line 197) | def classname(self): method classnaming (line 204) | def classnaming(self): method classnaming (line 210) | def classnaming(self, prefixed): method classof (line 219) | def classof(self, *args, **kwds): method copy (line 229) | def copy(self, deep=False, **name): method _DOT_ (line 243) | def _DOT_(self, *names): method dup (line 248) | def dup(self, deep=False, **items): method _instr (line 269) | def _instr(self, *attrs, **fmt_prec_props_sep_name__kwds): method iteration (line 290) | def iteration(self): # see .karney.GDict method methodname (line 299) | def methodname(self, which): method name (line 307) | def name(self): method name (line 313) | def name(self, name): method _name__ (line 334) | def _name__(self, name): # usually **name method _name1__ (line 339) | def _name1__(self, kwds): method named (line 345) | def named(self): method named2 (line 357) | def named2(self): method named3 (line 363) | def named3(self): method named4 (line 369) | def named4(self): method _notImplemented (line 374) | def _notImplemented(self, *args, **kwds): method _notOverloaded (line 379) | def _notOverloaded(self, *args, **kwds): method rename (line 384) | def rename(self, name): method renamed (line 397) | def renamed(self, name): method sizeof (line 408) | def sizeof(self): method toRepr (line 413) | def toRepr(self, **unused): # PYCHOK no cover method toStr (line 418) | def toStr(self, **unused): # PYCHOK no cover method toStr2 (line 424) | def toStr2(self, **kwds): # PYCHOK no cover method typename (line 437) | def typename(self): method _xnamed (line 442) | def _xnamed(self, inst, name=NN, **force): method _xrenamed (line 454) | def _xrenamed(self, inst): class _NamedBase (line 469) | class _NamedBase(_Named): method __repr__ (line 472) | def __repr__(self): method __str__ (line 477) | def __str__(self): method others (line 482) | def others(self, *other, **name_other_up): method toRepr (line 509) | def toRepr(self, **kwds): # PYCHOK expected method toStr (line 528) | def toStr(self, **kwds): # PYCHOK no cover method _update (line 539) | def _update(self, updated, *attrs, **setters): class _NamedDict (line 555) | class _NamedDict(ADict, _Named): method __init__ (line 559) | def __init__(self, *args, **kwds): method __delattr__ (line 571) | def __delattr__(self, name): method __getattr__ (line 582) | def __getattr__(self, name): method __getitem__ (line 592) | def __getitem__(self, key): method _KeyError (line 599) | def _KeyError(self, key, *value): # PYCHOK no cover method __setattr__ (line 608) | def __setattr__(self, name, value): method __setitem__ (line 616) | def __setitem__(self, key, value): class _NamedEnum (line 624) | class _NamedEnum(_NamedDict): method __init__ (line 630) | def __init__(self, Class, *Classes, **name): method __getattr__ (line 642) | def __getattr__(self, name): method __repr__ (line 647) | def __repr__(self): method __str__ (line 652) | def __str__(self): method _assert (line 657) | def _assert(self, **kwds): method _asserts (line 672) | def _asserts(self): # in .triaxials.triaxial3 method find (line 679) | def find(self, item, dflt=None, all=False): method get (line 695) | def get(self, name, dflt=None): method items (line 707) | def items(self, all=False, asorted=False): method keys (line 720) | def keys(self, **all_asorted): method popitem (line 729) | def popitem(self): method register (line 736) | def register(self, item): method unregister (line 769) | def unregister(self, name_or_item): method toRepr (line 795) | def toRepr(self, prec=6, fmt=Fmt.F, sep=_COMMANL_, **all_asorted): # ... method toStr (line 802) | def toStr(self, *unused, **all_asorted): # PYCHOK _NamedDict, ADict method values (line 807) | def values(self, **all_asorted): method _zapitem (line 816) | def _zapitem(self, name, item): class _LazyNamedEnumItem (line 824) | class _LazyNamedEnumItem(property_RO): # XXX or descriptor? function _lazyNamedEnumItem (line 830) | def _lazyNamedEnumItem(name, *args, **kwds): class _NamedEnumItem (line 863) | class _NamedEnumItem(_NamedBase): method name (line 876) | def name(self): method name (line 882) | def name(self, name): method _register (line 891) | def _register(self, enum, name): method unregister (line 904) | def unregister(self): class _NamedTuple (line 922) | class _NamedTuple(tuple, _Named): method __new__ (line 941) | def __new__(cls, arg, *args, **iteration_name): method __delattr__ (line 977) | def __delattr__(self, name): method __getattr__ (line 989) | def __getattr__(self, name): method __hash__ (line 1008) | def __hash__(self): method __repr__ (line 1011) | def __repr__(self): method __setattr__ (line 1016) | def __setattr__(self, name, value): method __str__ (line 1026) | def __str__(self): method _DOT_ (line 1031) | def _DOT_(self, *names): method dup (line 1036) | def dup(self, name=NN, **items): method items (line 1059) | def items(self): method reUnit (line 1069) | def reUnit(self, *Units, **name): method toRepr (line 1087) | def toRepr(self, prec=6, sep=_COMMASPACE_, fmt=Fmt.F, **unused): # PY... method toStr (line 1103) | def toStr(self, prec=6, sep=_COMMASPACE_, fmt=Fmt.F, **unused): # PYC... method toUnits (line 1117) | def toUnits(self, Error=UnitError, **name): # overloaded in .frechet,... method units (line 1131) | def units(self, **Error): method _validate (line 1147) | def _validate(self, underOK=False): # see .EcefMatrix method _xtend (line 1171) | def _xtend(self, xTuple, *items, **name): function callername (line 1184) | def callername(up=1, dflt=NN, source=False, underOK=False): function _callername2 (line 1208) | def _callername2(args, callername=NN, source=False, underOK=False, up=_U... function _callname (line 1216) | def _callname(name, class_name, self_name, up=1): function classname (line 1227) | def classname(inst, prefixed=None): function classnaming (line 1242) | def classnaming(prefixed=None): function modulename (line 1255) | def modulename(clas, prefixed=None): # in .basics._xversion function _name__ (line 1295) | def _name__(name=NN, **kwds): function _name1__ (line 1305) | def _name1__(kwds_name, **name__or_nameof): function _name2__ (line 1314) | def _name2__(name=NN, name__=None, _or_nameof=None, **kwds): function nameof (line 1332) | def nameof(inst): function _notDecap (line 1348) | def _notDecap(where): function _notError (line 1356) | def _notError(inst, name, args, kwds): # PYCHOK no cover function _NotImplemented (line 1364) | def _NotImplemented(inst, *other, **kwds): function notImplemented (line 1375) | def notImplemented(inst, *args, **kwds): # PYCHOK no cover function notOverloaded (line 1390) | def notOverloaded(inst, *args, **kwds): # PYCHOK no cover function _Pass (line 1404) | def _Pass(arg, **unused): # PYCHOK no cover function _xjoined_ (line 1410) | def _xjoined_(prefix, name=NN, enquote=True, **name__or_nameof): function _xnamed (line 1424) | def _xnamed(inst, name=NN, force=False, **name__or_nameof): function _xother3 (line 1444) | def _xother3(inst, other, name=_other_, up=1, **name_other): function _xotherError (line 1456) | def _xotherError(inst, other, name=_other_, up=1): function _xvalid (line 1463) | def _xvalid(name, underOK=False): FILE: pygeodesy/namedTuples.py class Bearing2Tuple (line 43) | class Bearing2Tuple(_NamedTuple): class Bounds2Tuple (line 50) | class Bounds2Tuple(_NamedTuple): # .geohash.py, .latlonBase.py, .points.py class Bounds4Tuple (line 58) | class Bounds4Tuple(_NamedTuple): # .geohash.py, .points.py method enclosures (line 66) | def enclosures(self, S_other, *W_N_E): method overlap (line 83) | def overlap(self, S_other, *W_N_E): class Circle4Tuple (line 100) | class Circle4Tuple(_NamedTuple): method abc3 (line 117) | def abc3(self): class Destination2Tuple (line 123) | class Destination2Tuple(_NamedTuple): # .ellipsoidalKarney.py, -Vincent... class Destination3Tuple (line 131) | class Destination3Tuple(_NamedTuple): # .karney.py class Distance2Tuple (line 140) | class Distance2Tuple(_NamedTuple): # .datum.py, .ellipsoidalBase.py class Distance3Tuple (line 148) | class Distance3Tuple(_NamedTuple): # .ellipsoidalKarney.py, -Vincenty.py class Distance4Tuple (line 156) | class Distance4Tuple(_NamedTuple): # .formy.py, .points.py class EasNor2Tuple (line 171) | class EasNor2Tuple(_NamedTuple): # .css, .osgr, .ups, .utm, .utmupsBase class EasNor3Tuple (line 178) | class EasNor3Tuple(_NamedTuple): # .css.py, .lcc.py class _Convergence (line 185) | class _Convergence(object): method convergence (line 188) | def convergence(self): class Ellipse5Tuple (line 194) | class Ellipse5Tuple(_NamedTuple): # in .triaxials.bases._UnOrderedTriax... method abc3 (line 210) | def abc3(self): method abc3ordered (line 216) | def abc3ordered(self): method toTriaxial (line 221) | def toTriaxial(self, **Triaxial_and_kwds): # like .Ellipse.toTriaxial_ method toTriaxial_ (line 230) | def toTriaxial_(self, **Triaxial_and_kwds): # like .Ellipse.toTriaxial_ class Forward4Tuple (line 240) | class Forward4Tuple(_NamedTuple, _Convergence): class Intersection3Tuple (line 249) | class Intersection3Tuple(_NamedTuple): # .css.py, .lcc.py class LatLon2Tuple (line 266) | class LatLon2Tuple(_NamedTuple): method to3Tuple (line 272) | def to3Tuple(self, height, **name): method to4Tuple (line 285) | def to4Tuple(self, height, datum, **name): class LatLon3Tuple (line 302) | class LatLon3Tuple(_NamedTuple): method to4Tuple (line 309) | def to4Tuple(self, datum, **name): class LatLon4Tuple (line 324) | class LatLon4Tuple(LatLon3Tuple): # .cartesianBase, .css, .ecef, .lcc function _LL4Tuple (line 332) | def _LL4Tuple(lat, lon, height, datum, LatLon, LatLon_kwds, inst=None, class LatLonDatum3Tuple (line 352) | class LatLonDatum3Tuple(_NamedTuple): # .lcc.py, .osgr.py class LatLonDatum5Tuple (line 360) | class LatLonDatum5Tuple(LatLonDatum3Tuple, _Convergence): # .ups.py, .u... class LatLonPrec3Tuple (line 368) | class LatLonPrec3Tuple(_NamedTuple): # .gars.py, .wgrs.py method to5Tuple (line 375) | def to5Tuple(self, height, radius, **name): class LatLonPrec5Tuple (line 389) | class LatLonPrec5Tuple(LatLonPrec3Tuple): # .wgrs.py class _NamedTupleTo (line 398) | class _NamedTupleTo(_NamedTuple): # in .testNamedTuples method _Degrees3 (line 401) | def _Degrees3(self, *xs, **toDMS_kwds): method _Radians3 (line 415) | def _Radians3(self, *xs, **unused): class NearestOn2Tuple (line 426) | class NearestOn2Tuple(_NamedTuple): # .ellipsoidalBaseDI class NearestOn3Tuple (line 439) | class NearestOn3Tuple(_NamedTuple): # .points.py, .sphericalTrigonometry class NearestOn5Tuple (line 453) | class NearestOn5Tuple(_NamedTuple): class NearestOn6Tuple (line 466) | class NearestOn6Tuple(_NamedTuple): # .latlonBase.py, .vector3d.py class NearestOn8Tuple (line 482) | class NearestOn8Tuple(_NamedTuple): # .ellipsoidalBaseDI class PhiLam2Tuple (line 492) | class PhiLam2Tuple(_NamedTuple): # .frechet, .hausdorff, .latlonBase, .... method to3Tuple (line 503) | def to3Tuple(self, height, **name): method to4Tuple (line 516) | def to4Tuple(self, height, datum): class PhiLam3Tuple (line 531) | class PhiLam3Tuple(_NamedTuple): # .nvector.py, extends -2Tuple method to4Tuple (line 543) | def to4Tuple(self, datum, **name): class PhiLam4Tuple (line 558) | class PhiLam4Tuple(_NamedTuple): # extends -3Tuple class Point3Tuple (line 571) | class Point3Tuple(_NamedTuple): class Points2Tuple (line 578) | class Points2Tuple(_NamedTuple): # .formy, .latlonBase class Reverse4Tuple (line 586) | class Reverse4Tuple(_NamedTuple, _Convergence): class Triangle7Tuple (line 596) | class Triangle7Tuple(_NamedTuple): class Triangle8Tuple (line 606) | class Triangle8Tuple(_NamedTuple): class Trilaterate5Tuple (line 616) | class Trilaterate5Tuple(_NamedTuple): # .latlonBase, .nvector class UtmUps2Tuple (line 635) | class UtmUps2Tuple(_NamedTuple): # .epsg.py class UtmUps5Tuple (line 644) | class UtmUps5Tuple(_NamedTuple): # .mgrs.py, .ups.py, .utm.py, .utmups.py method __new__ (line 654) | def __new__(cls, z, h, e, n, B, Error=None, **name): class UtmUps8Tuple (line 661) | class UtmUps8Tuple(_NamedTuple, _Convergence): # .ups, .utm, .utmups method __new__ (line 675) | def __new__(cls, z, h, e, n, B, d, g, s, Error=None, **name): # PYCHO... class UtmUpsLatLon5Tuple (line 684) | class UtmUpsLatLon5Tuple(_NamedTuple): # .ups.py, .utm.py, .utmups.py method __new__ (line 695) | def __new__(cls, z, B, h, lat, lon, Error=None, **name): class Vector2Tuple (line 702) | class Vector2Tuple(_NamedTuple): method toCartesian (line 709) | def toCartesian(self, Cartesian, **Cartesian_kwds): method to3Tuple (line 720) | def to3Tuple(self, z=INT0, **name): method xyz (line 734) | def xyz(self): method xyz3 (line 740) | def xyz3(self): class Vector3Tuple (line 746) | class Vector3Tuple(_NamedTuple): method toCartesian (line 753) | def toCartesian(self, Cartesian, **Cartesian_kwds): method to4Tuple (line 764) | def to4Tuple(self, h=INT0, **name): method xyz (line 778) | def xyz(self): method xyz3 (line 784) | def xyz3(self): class Vector4Tuple (line 790) | class Vector4Tuple(_NamedTuple): # .nvector.py method toCartesian (line 797) | def toCartesian(self, Cartesian, **Cartesian_kwds): method to3Tuple (line 808) | def to3Tuple(self): method xyz (line 816) | def xyz(self): method xyz3 (line 822) | def xyz3(self): function _v2Cls (line 828) | def _v2Cls(v, Cls, Cartesian_kwds): # in .vector3d FILE: pygeodesy/nvectorBase.py class NvectorBase (line 44) | class NvectorBase(Vector3d): # XXX kept private method __init__ (line 51) | def __init__(self, x_xyz, y=None, z=None, h=0, datum=None, **ll_name): method datum (line 76) | def datum(self): method Ecef (line 82) | def Ecef(self): method ellipsoidalNvector (line 88) | def ellipsoidalNvector(self): method h (line 94) | def h(self): method h (line 100) | def h(self, h): method H (line 113) | def H(self): method H (line 119) | def H(self, H): method hStr (line 124) | def hStr(self, prec=-2, m=NN): method isEllipsoidal (line 135) | def isEllipsoidal(self): method isSpherical (line 141) | def isSpherical(self): method lam (line 147) | def lam(self): method lat (line 153) | def lat(self): method latlon (line 159) | def latlon(self): method latlonheight (line 165) | def latlonheight(self): method latlonheightdatum (line 171) | def latlonheightdatum(self): method lon (line 177) | def lon(self): method phi (line 183) | def phi(self): method philam (line 189) | def philam(self): method philamheight (line 195) | def philamheight(self): method philamheightdatum (line 201) | def philamheightdatum(self): method sphericalNvector (line 207) | def sphericalNvector(self): method to2ab (line 213) | def to2ab(self): # PYCHOK no cover method to3abh (line 218) | def to3abh(self, height=None): # PYCHOK no cover method toCartesian (line 223) | def toCartesian(self, h=None, Cartesian=None, datum=None, **name_Carte... method _toEcefDrv3 (line 249) | def _toEcefDrv3(self, CC, LL, datum, h, name=NN, **unused): method to2ll (line 268) | def to2ll(self): # PYCHOK no cover method to3llh (line 273) | def to3llh(self, height=None): # PYCHOK no cover method toLatLon (line 278) | def toLatLon(self, height=None, LatLon=None, datum=None, **name_LatLon... method toStr (line 309) | def toStr(self, prec=5, fmt=Fmt.PAREN, sep=_COMMASPACE_): # PYCHOK ex... method toVector3d (line 326) | def toVector3d(self, norm=True): method to4xyzh (line 337) | def to4xyzh(self, h=None): # PYCHOK no cover method unit (line 342) | def unit(self, ll=None): method xyzh (line 352) | def xyzh(self): class _N_Vector (line 358) | class _N_Vector(NvectorBase): method __init__ (line 361) | def __init__(self, x, y, z, h=0, **name): class LatLonNvectorBase (line 373) | class LatLonNvectorBase(LatLonBase): method _update (line 377) | def _update(self, updated, *attrs, **setters): # PYCHOK _Nv=None method intersections2 (line 395) | def intersections2(self, radius1, other, radius2, **kwds): # PYCHOK e... method others (line 399) | def others(self, *other, **name_other_up): method toNvector (line 420) | def toNvector(self, **Nvector_and_kwds): # PYCHOK signature method triangulate (line 433) | def triangulate(self, bearing1, other, bearing2, height=None, wrap=Fal... method trilaterate (line 454) | def trilaterate(self, distance1, point2, distance2, point3, distance3, method trilaterate5 (line 492) | def trilaterate5(self, distance1, point2, distance2, point3, distance3... function n_xyz2latlon (line 521) | def n_xyz2latlon(x_xyz, y=0, z=0, **name): function n_xyz2philam (line 539) | def n_xyz2philam(x_xyz, y=0, z=0, **name): function _nsumOf (line 560) | def _nsumOf(nvs, h_None, Vector, Vector_kwds): # .sphericalNvector, .ve... function sumOf (line 579) | def sumOf(nvectors, Vector=None, h=None, **Vector_kwds): function _triangulate (line 600) | def _triangulate(point1, bearing1, point2, bearing2, height=None, function _trilaterate (line 629) | def _trilaterate(point1, distance1, point2, distance2, point3, distance3, FILE: pygeodesy/osgr.py class _NG (line 65) | class _NG(object): method a0 (line 69) | def a0(self): # equatoradius, scaled method b0 (line 73) | def b0(self): # polaradius, scaled method datum (line 77) | def datum(self): # datum, Airy130 ellipsoid method eas0 (line 81) | def eas0(self): # False origin easting (C{meter}) method easX (line 85) | def easX(self): # easting [0..extent] (C{meter}) method ellipsoid (line 89) | def ellipsoid(self): # ellipsoid, Airy130 method forward2 (line 92) | def forward2(self, latlon): # convert C{latlon} to (easting, norting)... method k0 (line 100) | def k0(self): # central scale (C{float}), like I{Karney}'s CentralScale method kTM (line 106) | def kTM(self): # the L{KTransverseMercator} instance, like I{Karney}'... method lam0 (line 111) | def lam0(self): # True origin longitude C{radians} method lat0 (line 115) | def lat0(self): # True origin latitude, 49°N method lon0 (line 119) | def lon0(self): # True origin longitude, 2°W method Mabcd (line 123) | def Mabcd(self): # meridional coefficients (a, b, c, d) method Mabcd0 (line 131) | def Mabcd0(self, a): # meridional arc, scaled method nor0 (line 140) | def nor0(self): # False origin northing (C{meter}) method nor0ffset (line 144) | def nor0ffset(self): # like I{Karney}'s computenorthoffset method norX (line 149) | def norX(self): # northing [0..extent] (C{meter}) method nu_rho_eta3 (line 152) | def nu_rho_eta3(self, sa): # 3-tuple (nu, nu / rho, eta2) method phi0 (line 163) | def phi0(self): # True origin latitude C{radians} method reverse (line 166) | def reverse(self, osgr): # convert C{osgr} to (ellipsoidal} LatLon, a... class OSGRError (line 180) | class OSGRError(_ValueError): class Osgr (line 186) | class Osgr(_NamedBase): method __init__ (line 198) | def __init__(self, easting, northing, datum=None, resolution=0, **name): method __str__ (line 226) | def __str__(self): method datum (line 230) | def datum(self): method easting (line 236) | def easting(self): method falsing0 (line 242) | def falsing0(self): method iteration (line 248) | def iteration(self): method latlon0 (line 255) | def latlon0(self): method northing (line 261) | def northing(self): method parse (line 266) | def parse(self, strOSGR, **name): method resolution (line 279) | def resolution(self): method toLatLon (line 284) | def toLatLon(self, LatLon=None, datum=_WGS84, kTM=False, eps=_10um, **... method scale0 (line 373) | def scale0(self): method toRepr (line 378) | def toRepr(self, GD=None, fmt=Fmt.SQUARE, sep=_COMMASPACE_, **prec): ... method toStr (line 413) | def toStr(self, GD=None, sep=NN, **prec): # PYCHOK expected function _GD_prec2 (line 466) | def _GD_prec2(GD, **prec_et_al): function _ll2datum (line 480) | def _ll2datum(ll, datum, name): function _ll2LatLon3 (line 492) | def _ll2LatLon3(ll, LatLon, datum, LatLon_kwds): function parseOSGR (line 508) | def parseOSGR(strOSGR, Osgr=Osgr, **name_Osgr_kwds): function toOsgr (line 579) | def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, # MCCA... function _rnd (line 682) | def _rnd(X, n): FILE: pygeodesy/points.py class LatLon_ (line 73) | class LatLon_(LatLonBase): # XXX in heights._HeightBase.height method __init__ (line 95) | def __init__(self, latlonh, lon=None, height=0, wrap=False, datum=None... method __eq__ (line 124) | def __eq__(self, other): method __ne__ (line 129) | def __ne__(self, other): method datum (line 133) | def datum(self): method intermediateTo (line 138) | def intermediateTo(self, other, fraction, height=None, wrap=False): method toRepr (line 170) | def toRepr(self, **kwds): method toStr (line 179) | def toStr(self, form=F_D, joined=_COMMASPACE_, **m_prec_sep_s_D_M_S): ... function _isLatLon (line 192) | def _isLatLon(inst): function _isLatLon_ (line 198) | def _isLatLon_(LL): class _Basequence (line 205) | class _Basequence(_Sequence): # immutable, on purpose method _contains (line 212) | def _contains(self, point): method copy (line 217) | def copy(self, deep=False): # PYCHOK no cover method _count (line 227) | def _count(self, point): method dup (line 232) | def dup(self, **items): # PYCHOK no cover method epsilon (line 247) | def epsilon(self): method epsilon (line 253) | def epsilon(self, tol): method _find (line 260) | def _find(self, point, start_end): method _findall (line 267) | def _findall(self, point, start_end): # PYCHOK no cover method _getitem (line 271) | def _getitem(self, index): method _index (line 281) | def _index(self, point, start_end): method isNumpy2 (line 289) | def isNumpy2(self): # PYCHOK no cover method isPoints2 (line 295) | def isPoints2(self): # PYCHOK no cover method isTuple2 (line 301) | def isTuple2(self): # PYCHOK no cover method _iter (line 306) | def _iter(self): method point (line 313) | def point(self, *attrs): # PYCHOK no cover method _range (line 317) | def _range(self, start=None, end=None, step=1): method _repr (line 334) | def _repr(self): method _reversed (line 343) | def _reversed(self): # PYCHOK false method _rfind (line 350) | def _rfind(self, point, start_end): method _slicekwds (line 360) | def _slicekwds(self): # PYCHOK no cover class _Array2LatLon (line 366) | class _Array2LatLon(_Basequence): # immutable, on purpose method __init__ (line 375) | def __init__(self, array, ilat=0, ilon=1, LatLon=None, shape=()): method __contains__ (line 403) | def __contains__(self, latlon): method __getitem__ (line 415) | def __getitem__(self, index): method __iter__ (line 420) | def __iter__(self): method __len__ (line 425) | def __len__(self): method __repr__ (line 430) | def __repr__(self): method __reversed__ (line 435) | def __reversed__(self): # PYCHOK false method count (line 442) | def count(self, latlon): method find (line 454) | def find(self, latlon, *start_end): method _findall (line 466) | def _findall(self, latlon, start_end): method findall (line 485) | def findall(self, latlon, *start_end): method index (line 498) | def index(self, latlon, *start_end): # PYCHOK Python 2- issue method ilat (line 514) | def ilat(self): method ilon (line 520) | def ilon(self): method point (line 527) | def point(self, row): # PYCHOK *attrs method rfind (line 536) | def rfind(self, latlon, *start_end): method _slicekwds (line 551) | def _slicekwds(self): method shape (line 557) | def shape(self): method _subset (line 563) | def _subset(self, indices): # PYCHOK no cover method subset (line 567) | def subset(self, indices): class LatLon2psxy (line 599) | class LatLon2psxy(_Basequence): method __init__ (line 608) | def __init__(self, latlons, closed=False, radius=None, wrap=True): method __contains__ (line 635) | def __contains__(self, xy): method __getitem__ (line 647) | def __getitem__(self, index): method __iter__ (line 652) | def __iter__(self): method __len__ (line 657) | def __len__(self): method __repr__ (line 662) | def __repr__(self): method __reversed__ (line 667) | def __reversed__(self): # PYCHOK false method count (line 674) | def count(self, xy): method find (line 686) | def find(self, xy, *start_end): method _findall (line 699) | def _findall(self, xy, start_end): method findall (line 723) | def findall(self, xy, *start_end): method index (line 736) | def index(self, xy, *start_end): # PYCHOK Python 2- issue method isPoints2 (line 751) | def isPoints2(self): method point (line 756) | def point(self, ll): # PYCHOK *attrs method rfind (line 772) | def rfind(self, xy, *start_end): method _slicekwds (line 785) | def _slicekwds(self): class Numpy2LatLon (line 791) | class Numpy2LatLon(_Array2LatLon): # immutable, on purpose method __init__ (line 794) | def __init__(self, array, ilat=0, ilon=1, LatLon=None): method isNumpy2 (line 832) | def isNumpy2(self): method _subset (line 837) | def _subset(self, indices): class Shape2Tuple (line 841) | class Shape2Tuple(_NamedTuple): class Tuple2LatLon (line 849) | class Tuple2LatLon(_Array2LatLon): method __init__ (line 852) | def __init__(self, tuples, ilat=0, ilon=1, LatLon=None): method isTuple2 (line 903) | def isTuple2(self): method _subset (line 908) | def _subset(self, indices): function _area2 (line 912) | def _area2(points, adjust, wrap): function _areaError (line 943) | def _areaError(pts, near_=NN): # in .ellipsoidalKarney function areaOf (line 950) | def areaOf(points, adjust=True, radius=R_M, wrap=True): function boundsOf (line 985) | def boundsOf(points, wrap=False, LatLon=None): # was=True function centroidOf (line 1028) | def centroidOf(points, wrap=False, LatLon=None): # was=True function _distanceTo (line 1082) | def _distanceTo(Error, **name_points): # .frechet, .hausdorff, .heights function fractional (line 1094) | def fractional(points, fi, j=None, wrap=None, LatLon=None, Vector=None, ... function _fractional (line 1175) | def _fractional(points, fi, j, fin=None, wrap=None, dup=False): # in .f... function isclockwise (line 1204) | def isclockwise(points, adjust=False, wrap=True): function isconvex (line 1230) | def isconvex(points, adjust=False, wrap=False): # was=True function isconvex_ (line 1250) | def isconvex_(points, adjust=False, wrap=False): # was=True function isenclosedBy (line 1314) | def isenclosedBy(point, points, wrap=False): # MCCABE 15 function ispolar (line 1403) | def ispolar(points, wrap=False): function luneOf (line 1439) | def luneOf(lon1, lon2, closed=False, LatLon=LatLon_, **LatLon_kwds): function nearestOn5 (line 1465) | def nearestOn5(point, points, closed=False, wrap=False, adjust=True, function perimeterOf (line 1586) | def perimeterOf(points, closed=False, adjust=True, radius=R_M, wrap=True): function quadOf (line 1639) | def quadOf(latS, lonW, latN, lonE, closed=False, LatLon=LatLon_, **LatLo... FILE: pygeodesy/props.py function _allPropertiesOf (line 40) | def _allPropertiesOf(Clas_or_inst, *Bases, **excls): function _allPropertiesOf_n (line 61) | def _allPropertiesOf_n(n, Clas_or_inst, *Bases, **excls): function _hasProperty (line 71) | def _hasProperty(inst, name, *Classes): # in .named._NamedBase._update function _update_all (line 86) | def _update_all(inst, *attrs, **Base_needed): function _update_attrs (line 133) | def _update_attrs(inst, *attrs): class _PropertyBase (line 157) | class _PropertyBase(property): method __init__ (line 160) | def __init__(self, method, fget, fset, doc=NN): method _Error (line 172) | def _Error(self, kind, nameter, farg): method _fdel (line 183) | def _fdel(self, inst): method _fget (line 188) | def _fget(self, inst): method _fset_error (line 198) | def _fset_error(self, inst, val): method _update (line 206) | def _update(self, inst, *unused): method _update_from (line 211) | def _update_from(self, inst, other): method deleter (line 222) | def deleter(self, fdel): method getter (line 227) | def getter(self, fget): method setter (line 232) | def setter(self, fset): class Property_RO (line 238) | class Property_RO(_PropertyBase): method __init__ (line 240) | def __init__(self, method, doc=NN): # PYCHOK expected method __get__ (line 263) | def __get__(self, inst, *unused): # PYCHOK 2 vs 3 args class Property (line 272) | class Property(Property_RO): method setter (line 284) | def setter(self, method): method setter_ (line 300) | def setter_(self, method): method _setters (line 315) | def _setters(self, method, _fset): class property_RO (line 324) | class property_RO(_PropertyBase): method __init__ (line 328) | def __init__(self, method, doc=NN): # PYCHOK expected method _update (line 342) | def _update(self, inst, *Clas): # PYCHOK signature class _property_RO___ (line 360) | class _property_RO___(_PropertyBase): method __init__ (line 363) | def __init__(self, method, doc=NN): # PYCHOK expected method _fdel (line 372) | def _fdel(self, *unused): # PYCHOK no cover method _update (line 377) | def _update(self, *unused): # PYCHOK signature class property_ROnce (line 383) | class property_ROnce(_property_RO___): method _fget (line 386) | def _fget(self, inst): class property_ROver (line 396) | class property_ROver(_property_RO___): method _fget (line 399) | def _fget(self, inst): class _NamedProperty (line 417) | class _NamedProperty(property): # in .named method name (line 421) | def name(self): function property_doc_ (line 427) | def property_doc_(doc): function _deprecated (line 457) | def _deprecated(call, kind, qual_d): function deprecated_class (line 479) | def deprecated_class(cls_or_class): function deprecated_function (line 491) | def deprecated_function(call): function deprecated_method (line 503) | def deprecated_method(call): function _deprecated_module (line 513) | def _deprecated_module(name): # PYCHOK no cover function _DEPRECATEDof (line 520) | def _DEPRECATEDof(obj): class deprecated_property (line 532) | class deprecated_property(_PropertyBase): method __init__ (line 535) | def __init__(self, method): method setter (line 549) | def setter(self, method): class deprecated_property (line 577) | class deprecated_property(property): # PYCHOK expected method __init__ (line 535) | def __init__(self, method): method setter (line 549) | def setter(self, method): function deprecated_Property_RO (line 585) | def deprecated_Property_RO(method): function deprecated_property_RO (line 595) | def deprecated_property_RO(method): function _deprecated_RO (line 605) | def _deprecated_RO(method, _RO): function _qualified (line 628) | def _qualified(inst, name): class DeprecationWarnings (line 637) | class DeprecationWarnings(object): method __call__ (line 642) | def __call__(self): # for backward compatibility method _Fmt (line 656) | def _Fmt(self): method _stacklevel3 (line 662) | def _stacklevel3(self): method throw (line 667) | def throw(self, kind, name, doc, **stacklevel): # stacklevel=3 method _warn (line 686) | def _warn(self): method Warnings (line 693) | def Warnings(self): FILE: pygeodesy/resections.py class Collins5Tuple (line 50) | class Collins5Tuple(_NamedTuple): class ResectionError (line 59) | class ResectionError(_ValueError): class Survey3Tuple (line 65) | class Survey3Tuple(_NamedTuple): class Tienstra7Tuple (line 73) | class Tienstra7Tuple(_NamedTuple): class TriAngle5Tuple (line 82) | class TriAngle5Tuple(_NamedTuple): class TriSide2Tuple (line 92) | class TriSide2Tuple(_NamedTuple): class TriSide4Tuple (line 100) | class TriSide4Tuple(_NamedTuple): function _ABC3 (line 110) | def _ABC3(useZ, pointA, pointB, pointC): function _B3 (line 118) | def _B3(useZ, point1, point2, point3): function cassini (line 126) | def cassini(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and_... function _Clas (line 200) | def _Clas(which, point, Clas_and_kwds, *args): function collins5 (line 207) | def collins5(pointA, pointB, pointC, alpha, beta, useZ=False, **Clas_and... function _noneg (line 293) | def _noneg(*xs): function pierlot (line 302) | def pierlot(point1, point2, point3, alpha12, alpha23, useZ=False, eps=EPS, function _pierlot3 (line 362) | def _pierlot3(B1, B2, B3, a12, a23, useZ, _cot): function pierlotx (line 415) | def pierlotx(point1, point2, point3, alpha1, alpha2, alpha3, useZ=False, function _pierlotx3 (line 475) | def _pierlotx3(a_z_Bs, useZ, _cot, Cs): function _pierlotxy2 (line 521) | def _pierlotxy2(B, K, X, Y, D): function _rotate (line 532) | def _rotate(xs, n=1): function snellius3 (line 538) | def snellius3(a, b, degC, alpha, beta): function tienstra7 (line 589) | def tienstra7(pointA, pointB, pointC, alpha, beta=None, gamma=None, function triAngle (line 686) | def triAngle(a, b, c): function _triAngle (line 709) | def _triAngle(a, b, c): function triAngle5 (line 723) | def triAngle5(a, b, c): function triArea (line 782) | def triArea(a, b, c): function triSide (line 815) | def triSide(a, b, radC): function _triSide (line 839) | def _triSide(a, b, radC): function triSide2 (line 854) | def triSide2(b, c, radB): function _triSide2 (line 879) | def _triSide2(b, c, radB): function triSide4 (line 900) | def triSide4(radA, radB, c): function wildberger3 (line 940) | def wildberger3(a, b, c, alpha, beta, R3=min): function _zidw (line 1020) | def _zidw(x, y, useZ, *ABC): FILE: pygeodesy/rhumb/aux_.py class RhumbAux (line 64) | class RhumbAux(RhumbBase): method __init__ (line 72) | def __init__(self, a_earth=_WGS84, f=None, exact=True, **TMorder_name)... method areaux (line 94) | def areaux(self, **exact): method _auxD (line 118) | def _auxD(self): method _c2 (line 122) | def _c2(self): # radians makes _c2 a factor per degree method _DMu_DPsi (line 125) | def _DMu_DPsi(self, Phi1, Phi2, Chi1, Chi2): method _Inverse4 (line 134) | def _Inverse4(self, lon12, r, outmask): method _latPhi2 (line 154) | def _latPhi2(self, mu): method _mpd (line 160) | def _mpd(self): # meter per degree method _psiChiPhi3 (line 163) | def _psiChiPhi3(self, lat): method _RA (line 170) | def _RA(self): # get the coefficients for area calculation method _rrm (line 177) | def _rrm(self): method _S12d (line 182) | def _S12d(self, Chix, Chiy, lon12): # degrees class RhumbLineAux (line 203) | class RhumbLineAux(RhumbLineBase): method __init__ (line 212) | def __init__(self, rhumb, lat1=0, lon1=0, azi12=None, **caps_name): #... method _Chi1 (line 228) | def _Chi1(self): method _mu1 (line 232) | def _mu1(self): method _mu2lat (line 237) | def _mu2lat(self, mu): method _Phi1 (line 244) | def _Phi1(self): method _Position4 (line 247) | def _Position4(self, a12, mu2, *unused): # PYCHOK s12, mu2 function _RAintegrate (line 267) | def _RAintegrate(auxD): function _RAseries (line 296) | def _RAseries(auxD): FILE: pygeodesy/rhumb/bases.py class _Lat (line 62) | class _Lat(Lat): method __init__ (line 65) | def __init__(self, *lat, **Error_name): class _Lon (line 70) | class _Lon(Lon): method __init__ (line 73) | def __init__(self, *lon, **Error_name): function _update_all_rls (line 78) | def _update_all_rls(r): class RhumbBase (line 90) | class RhumbBase(_CapsBase): method __init__ (line 98) | def __init__(self, a_earth, f, exact, TMorder_name): method a (line 115) | def a(self): method ArcDirect (line 122) | def ArcDirect(self, lat1, lon1, azi12, a12, outmask=Caps.LATITUDE_LONG... method b (line 154) | def b(self): method datum (line 162) | def datum(self): method datum (line 168) | def datum(self, datum): method _Direct (line 179) | def _Direct(self, ll1, azi12, s12, **outmask): method Direct (line 184) | def Direct(self, lat1, lon1, azi12, s12, outmask=Caps.LATITUDE_LONGITU... method Direct8 (line 215) | def Direct8(self, lat1, lon1, azi12, s12, outmask=Caps.LATITUDE_LONGIT... method _DirectLine (line 220) | def _DirectLine(self, ll1, azi12, **caps_name): method DirectLine (line 225) | def DirectLine(self, lat1, lon1, azi12, **caps_name): method _DirectRhumb (line 249) | def _DirectRhumb(self, lat1, lon1, azi12, a12, s12, outmask): method ellipsoid (line 257) | def ellipsoid(self): method ellipsoid (line 263) | def ellipsoid(self, a_earth_f): method exact (line 272) | def exact(self): method exact (line 278) | def exact(self, exact): method _exactest (line 295) | def _exactest(self, exact, ellipsoid, f_max): method f (line 301) | def f(self): method f_max (line 309) | def f_max(self): method f_max (line 315) | def f_max(self, f_max): # PYCHOK no cover method _Inverse (line 326) | def _Inverse(self, ll1, ll2, wrap, **outmask): method Inverse (line 333) | def Inverse(self, lat1, lon1, lat2, lon2, outmask=Caps.AZIMUTH_DISTANCE): method _Inverse4 (line 376) | def _Inverse4(self, lon12, r, outmask): # PYCHOK no cover method Inverse8 (line 380) | def Inverse8(self, lat1, lon1, azi12, s12, outmask=Caps.AZIMUTH_DISTAN... method _InverseLine (line 385) | def _InverseLine(self, ll1, ll2, wrap, **caps_name): method InverseLine (line 392) | def InverseLine(self, lat1, lon1, lat2, lon2, **caps_name): method _mpd (line 416) | def _mpd(self): # PYCHOK no cover method RAorder (line 421) | def RAorder(self): method _RhumbLine (line 427) | def _RhumbLine(self): # PYCHOK no cover method _S12d (line 431) | def _S12d(self, s1, s2, lon): # PYCHOK no cover method TMorder (line 436) | def TMorder(self): method TMorder (line 442) | def TMorder(self, order): method toStr (line 455) | def toStr(self, prec=6, sep=_COMMASPACE_, **unused): # PYCHOK signature class RhumbLineBase (line 470) | class RhumbLineBase(_CapsBase): method __init__ (line 485) | def __init__(self, rhumb, lat1, lon1, azi12, caps=Caps.STANDARD, name=... method __del__ (line 508) | def __del__(self): # XXX use weakref? method ArcPosition (line 517) | def ArcPosition(self, a12, outmask=Caps.LATITUDE_LONGITUDE): method azi12 (line 547) | def azi12(self): method azi12 (line 553) | def azi12(self, azi12): method azi12_sincos2 (line 565) | def azi12_sincos2(self): # PYCHOK no cover method datum (line 571) | def datum(self): method degrees2m (line 576) | def degrees2m(self, angle): method distance2 (line 586) | def distance2(self, lat, lon): # PYCHOK no cover method ellipsoid (line 596) | def ellipsoid(self): method exact (line 602) | def exact(self): method Intersecant2 (line 607) | def Intersecant2(self, lat0, lon0, radius, napier=True, **tol_eps): method intersection2 (line 662) | def intersection2(self, other, **tol_eps): # PYCHOK no cover method Intersection (line 669) | def Intersection(self, other, tol=_TOL, **eps): method Inverse (line 738) | def Inverse(self, lat2, lon2, wrap=False, **outmask): method isLoxodrome (line 759) | def isLoxodrome(self): method lat1 (line 769) | def lat1(self): method lon1 (line 775) | def lon1(self): method latlon1 (line 781) | def latlon1(self): method m2degrees (line 786) | def m2degrees(self, distance): method _mu1 (line 796) | def _mu1(self): # PYCHOK no cover method _mu2lat (line 800) | def _mu2lat(self, mu2): # PYCHOK no cover method nearestOn4 (line 805) | def nearestOn4(self, lat0, lon0, **exact_eps_est_tol): # PYCHOK no cover method NearestOn (line 814) | def NearestOn(self, lat0, lon0, **exact_eps_est_tol): # PYCHOK no cover method PlumbTo (line 818) | def PlumbTo(self, lat0, lon0, exact=None, eps=EPS, est=None, tol=_TOL): method Position (line 908) | def Position(self, s12, outmask=Caps.LATITUDE_LONGITUDE): method _Position (line 936) | def _Position(self, a12, s12, outmask): method _Position4 (line 975) | def _Position4(self, a12, mu2, s12, mu12): # PYCHOK no cover method rhumb (line 980) | def rhumb(self): method toStr (line 985) | def toStr(self, prec=6, sep=_COMMASPACE_, **unused): # PYCHOK signature method TMorder (line 1001) | def TMorder(self): method xTM (line 1007) | def xTM(self): method _xTM3d (line 1016) | def _xTM3d(self, latlon0, z=INT0, V3d=Vector3d): class _PseudoRhumbLine (line 1024) | class _PseudoRhumbLine(RhumbLineBase): method __init__ (line 1027) | def __init__(self, gl, name=NN): method PlumbTo (line 1034) | def PlumbTo(self, lat0, lon0, **exact_eps_est_tol): # PYCHOK signature method Position (line 1040) | def Position(self, s12, **unused): # PYCHOK signature function _ref (line 1078) | def _ref(fmt, r3, x3): FILE: pygeodesy/rhumb/ekx.py class Rhumb (line 48) | class Rhumb(RhumbBase): method __init__ (line 57) | def __init__(self, a_earth=_WGS84, f=None, exact=True, **RA_TMorder_na... method _A2 (line 85) | def _A2(self): # Conformal2RectifyingCoeffs method _B2 (line 90) | def _B2(self): # Rectifying2ConformalCoeffs method _DConformal2Rectifying (line 94) | def _DConformal2Rectifying(self, x, y): # radians method Direct7 (line 98) | def Direct7(self, lat1, lon1, azi12, s12, outmask=Caps.LATITUDE_LONGIT... method _DIsometrict (line 105) | def _DIsometrict(self, phix, phiy, tphix, tphiy, _Dtan_phix_phiy): method _DIsometric2Rectifyingd (line 110) | def _DIsometric2Rectifyingd(self, psix, psiy): # degrees method _DRectifyingt (line 122) | def _DRectifyingt(self, tphix, tphiy, _Dtan_phix_phiy): method _DRectifying2Conformal (line 130) | def _DRectifying2Conformal(self, x, y): # radians method _DRectifying2Isometricd (line 133) | def _DRectifying2Isometricd(self, mux, muy): # degrees method _eF (line 146) | def _eF(self): method _Inverse4 (line 152) | def _Inverse4(self, lon12, r, outmask): method Inverse7 (line 175) | def Inverse7(self, lat1, lon1, azi12, s12, outmask=Caps.AZIMUTH_DISTAN... method _mpd (line 183) | def _mpd(self): # meter per degree method _mpr (line 187) | def _mpr(self): # meter per radian method orders (line 191) | def orders(self, RAorder=6, TMorder=6): # PYCHOK no cover method _RA2 (line 212) | def _RA2(self): method RAorder (line 219) | def RAorder(self): method RAorder (line 225) | def RAorder(self, order): method _S12d (line 235) | def _S12d(self, psi1, psi2, lon12): # degrees class RhumbLine (line 249) | class RhumbLine(RhumbLineBase): method __init__ (line 258) | def __init__(self, rhumb, lat1=0, lon1=0, azi12=None, **caps_name): #... method _dpm12 (line 274) | def _dpm12(self): # PYCHOK no cover method _mu1 (line 283) | def _mu1(self): method _mu2lat (line 288) | def _mu2lat(self, mu): method _Position4 (line 293) | def _Position4(self, unused, mu2, s12, mu12): method _psi1 (line 308) | def _psi1(self): method RAorder (line 314) | def RAorder(self): function _Dasinh (line 328) | def _Dasinh(x, y): function _Datan (line 341) | def _Datan(x, y): function _Dcosh (line 352) | def _Dcosh(x, y): function _DeatanhE (line 356) | def _DeatanhE(x, y, E): # see .albers._Datanhee function _DfEt (line 365) | def _DfEt(tx, ty, eF): # tangents function _Dgd (line 400) | def _Dgd(x, y): function _Dgdinv (line 404) | def _Dgdinv(x, y): # x, y are tangents function _Dlog (line 408) | def _Dlog(x, y): function _Dsin (line 418) | def _Dsin(x, y): function _Dsincos (line 422) | def _Dsincos(x, y, sin_, cos_): function _Dsinh (line 430) | def _Dsinh(x, y): function _Dtan (line 434) | def _Dtan(x, y): # PYCHOK no cover function _Dtant (line 438) | def _Dtant(dxy, tx, ty): function _Eaux4 (line 446) | def _Eaux4(E_aux, mu_psi_x, mu_psi_y): # degrees function _gd (line 453) | def _gd(x): function _sincosSeries (line 457) | def _sincosSeries(sinp, x, y, C, n): FILE: pygeodesy/rhumb/solve.py class _RhumbSolveBase (line 28) | class _RhumbSolveBase(_SolveGDictBase): method _cmdBasic (line 39) | def _cmdBasic(self): method RhumbSolve (line 47) | def RhumbSolve(self): method RhumbSolve (line 54) | def RhumbSolve(self, path): method _s_option (line 64) | def _s_option(self): # == not -E for GeodSolve class RhumbSolve (line 72) | class RhumbSolve(_RhumbSolveBase): method _azimuth_reverse (line 103) | def _azimuth_reverse(self, azimuth): method _Direct (line 111) | def _Direct(self, ll1, azi12, s12, **outmask): method Direct3 (line 116) | def Direct3(self, lat1, lon1, azi1, s12): # PYCHOK outmask method _DirectLine (line 127) | def _DirectLine(self, ll1, azi12, **name_caps): method DirectLine (line 132) | def DirectLine(self, lat1, lon1, azi1, caps=Caps.STANDARD, **name): method _GDictDirect (line 156) | def _GDictDirect(self, lat, lon, azi1, arcmode, s12_a12, *unused, **fl... method _GDictInverse (line 164) | def _GDictInverse(self, lat1, lon1, lat2, lon2, *unused, **floats): #... method _Inverse (line 173) | def _Inverse(self, ll1, ll2, wrap, **unused): method Inverse3 (line 180) | def Inverse3(self, lat1, lon1, lat2, lon2): # PYCHOK outmask method _InverseLine (line 191) | def _InverseLine(self, ll1, ll2, wrap, **name_caps): method InverseLine (line 198) | def InverseLine(self, lat1, lon1, lat2, lon2, caps=Caps.STANDARD, **na... method toStr (line 221) | def toStr(self, **prec_sep_other): # PYCHOK signature class RhumbLineSolve (line 231) | class RhumbLineSolve(_RhumbSolveBase, _SolveGDictLineBase): method __init__ (line 241) | def __init__(self, rhumb, lat1, lon1, azi12, caps=Caps.STANDARD, **name): method azi12 (line 288) | def azi12(self): method azi12_sincos2 (line 296) | def azi12_sincos2(self): # PYCHOK no cover method Position (line 309) | def Position(self, s12, **unused): method toStr (line 322) | def toStr(self, **prec_sep_other): # PYCHOK signature class RhumbSolve7Tuple (line 332) | class RhumbSolve7Tuple(Rhumb8Tuple): function rhumb_intercept (line 350) | def rhumb_intercept(rS, lat1, lon1, lat2, lon2, azi2, s23): FILE: pygeodesy/simplify.py class _T2 (line 97) | class _T2(object): method __init__ (line 104) | def __init__(self, ix, h2): class _Sy (line 109) | class _Sy(object): method __init__ (line 126) | def __init__(self, points, tolerance, radius, shortest, method d21 (line 153) | def d21(self, s, e): method d2i2 (line 160) | def d2i2(self, m, n, modified): method d2ix2 (line 174) | def d2ix2(self, m, n, modified): method d2yxu4 (line 209) | def d2yxu4(self, i, j): method h2t (line 217) | def h2t(self, i1, i2, i3): method rdp (line 232) | def rdp(self, modified): method result (line 257) | def result(self, r): method rw (line 268) | def rw(self): method sy1 (line 287) | def sy1(self): method vwn (line 300) | def vwn(self): method vwr (line 316) | def vwr(self, attr): method vwrm (line 341) | def vwrm(self): method vwrm1 (line 356) | def vwrm1(self, m, tol): method vwrm2 (line 371) | def vwrm2(self, tol): function simplify1 (line 384) | def simplify1(points, distance=_1mm, radius=R_M, indices=False, **options): function simplifyRDP (line 407) | def simplifyRDP(points, distance=_1mm, radius=R_M, shortest=False, function simplifyRW (line 443) | def simplifyRW(points, pipe=_1mm, radius=R_M, shortest=False, function simplifyVW (line 471) | def simplifyVW(points, area=_1mm, radius=R_M, indices=False, FILE: pygeodesy/solveBase.py function _cmd_stdin_ (line 31) | def _cmd_stdin_(cmd, stdin): # PYCHOK no cover class _SolveCapsBase (line 48) | class _SolveCapsBase(_CapsBase): method a (line 65) | def a(self): method b (line 71) | def b(self): method _cmdBasic (line 77) | def _cmdBasic(self): # PYCHOK no covers '''(INTERNAL) I{Must b... method datum (line 81) | def datum(self): method _Dict (line 86) | def _Dict(self, Dict, n, v, floats=True, **unused): method _DictInvoke2 (line 93) | def _DictInvoke2(self, cmd, args, Names, Dict, **floats_R): method _Dicts (line 113) | def _Dicts(self, Dict, Names, t, **floats_R): method _E_option (line 123) | def _E_option(self): method Exact (line 127) | def Exact(self): method Exact (line 133) | def Exact(self, Exact): method ellipsoid (line 143) | def ellipsoid(self): method _e_option (line 149) | def _e_option(self): method flattening (line 157) | def flattening(self): method invokat (line 165) | def invokat(self, *prefix): method invokation (line 176) | def invokation(self): method invoke (line 181) | def invoke(self, *options, **stdin): method _invoke (line 209) | def _invoke(self, cmd, stdin=None, **unused): # _R=None method linelimit (line 229) | def linelimit(self, *limit): method _mpd (line 244) | def _mpd(self): # meter per degree method _p_option (line 248) | def _p_option(self): method prec (line 252) | def prec(self): method prec (line 258) | def prec(self, prec): method _print (line 271) | def _print(self, line, *suffix): # PYCHOK no cover method _setXable (line 282) | def _setXable(self, path, **Xable_path): method status (line 301) | def status(self): method _toStdin (line 307) | def _toStdin(self, floats): method verbose (line 313) | def verbose(self): method verbose (line 319) | def verbose(self, verbose): method version (line 326) | def version(self): class _SolveBase (line 332) | class _SolveBase(_SolveCapsBase): method reverse2 (line 341) | def reverse2(self): method reverse2 (line 347) | def reverse2(self, reverse2): method toStr (line 355) | def toStr(self, prec=6, sep=_COMMASPACE_, **other): # PYCHOK signature method unroll (line 367) | def unroll(self): method unroll (line 373) | def unroll(self, unroll): class _Solve3Base (line 382) | class _Solve3Base(_SolveBase): method _cmdDirect (line 387) | def _cmdDirect(self): method _cmdInverse (line 393) | def _cmdInverse(self): method _GDictDirect (line 398) | def _GDictDirect(self, lat, lon, azi, arcmode, s12_a12, outmask=_UNUSE... method _GDictInverse (line 406) | def _GDictInverse(self, lat1, lon1, lat2, lon2, outmask=_UNUSED_, **fl... method _GDictInvoke (line 412) | def _GDictInvoke(self, cmd, Names, *args, **floats): method toStr (line 417) | def toStr(self, **prec_sep_other): # PYCHOK signature class _SolveGDictBase (line 426) | class _SolveGDictBase(_Solve3Base): method __init__ (line 430) | def __init__(self, a_ellipsoid=_EWGS84, f=None, path=NN, **name): method ArcDirect (line 450) | def ArcDirect(self, lat1, lon1, azi1, a12, outmask=_UNUSED_): # PYCHO... method Direct (line 455) | def Direct(self, lat1, lon1, azi1, s12, outmask=_UNUSED_): # PYCHOK u... method Inverse (line 460) | def Inverse(self, lat1, lon1, lat2, lon2, outmask=_UNUSED_): # PYCHOK... method Inverse1 (line 465) | def Inverse1(self, lat1, lon1, lat2, lon2, wrap=False): method toStr (line 475) | def toStr(self, **prec_sep_other): # PYCHOK signature class _SolveGDictLineBase (line 481) | class _SolveGDictLineBase(_SolveGDictBase): method __init__ (line 488) | def __init__(self, solve, lat1, lon1, caps, **azi_name): method _cmdDistance (line 499) | def _cmdDistance(self): method datum (line 509) | def datum(self): method ellipsoid (line 515) | def ellipsoid(self): method lat1 (line 521) | def lat1(self): method lon1 (line 527) | def lon1(self): method toStr (line 532) | def toStr(self, **prec_sep_other): # PYCHOK signature FILE: pygeodesy/sphericalBase.py class CartesianSphericalBase (line 46) | class CartesianSphericalBase(CartesianBase): method intersections2 (line 51) | def intersections2(self, rad1, other, rad2, radius=R_M): method sphericalCartesian (line 108) | def sphericalCartesian(self): class LatLonSphericalBase (line 114) | class LatLonSphericalBase(LatLonBase): method __init__ (line 120) | def __init__(self, latlonh, lon=None, height=0, datum=None, wrap=False... method bearingTo2 (line 143) | def bearingTo2(self, other, wrap=False, raiser=False): method datum (line 163) | def datum(self): method datum (line 169) | def datum(self, datum): method finalBearingTo (line 180) | def finalBearingTo(self, other, wrap=False, raiser=False): method intersecant2 (line 199) | def intersecant2(self, circle, point, other, radius=R_M, exact=False, ... method maxLat (line 240) | def maxLat(self, bearing): method minLat (line 258) | def minLat(self, bearing): method _mpr (line 272) | def _mpr(self, radius=R_M, exact=None): # meter per radian method napieradius (line 278) | def napieradius(self): method napieradius (line 284) | def napieradius(self, radius): method parse (line 303) | def parse(self, strllh, height=0, sep=_COMMA_, **name): method _radius (line 321) | def _radius(self): method _rhumbs3 (line 326) | def _rhumbs3(self, other, wrap, r=False): # != .latlonBase._rhumbx3 method rhumbAzimuthTo (line 350) | def rhumbAzimuthTo(self, other, radius=R_M, exact=False, wrap=False, b... method rhumbBearingTo (line 377) | def rhumbBearingTo(self, other): # unwrapped method rhumbDestination (line 381) | def rhumbDestination(self, distance, azimuth, radius=R_M, height=None, method rhumbDistanceTo (line 431) | def rhumbDistanceTo(self, other, radius=R_M, exact=False, wrap=False): method rhumbIntersecant2 (line 463) | def rhumbIntersecant2(self, circle, point, other, radius=R_M, exact=Tr... method rhumbMidpointTo (line 500) | def rhumbMidpointTo(self, other, height=None, radius=R_M, exact=False, method sphericalLatLon (line 567) | def sphericalLatLon(self): method toNvector (line 572) | def toNvector(self, Nvector=NvectorBase, **Nvector_kwds): # PYCHOK si... function _intersecant2 (line 587) | def _intersecant2(c, r, p, b, radius=R_M, exact=False, height=None, wrap... function _logPI_2_2 (line 653) | def _logPI_2_2(a2, a1): function _m2radians (line 659) | def _m2radians(distance, radius, low=EPS): # PYCHOK in .spherical* function _radians2m (line 674) | def _radians2m(rad, radius): function _rads3 (line 682) | def _rads3(rad1, rad2, radius): # in .sphericalTrigonometry FILE: pygeodesy/sphericalNvector.py class Cartesian (line 70) | class Cartesian(CartesianSphericalBase): method toLatLon (line 75) | def toLatLon(self, **LatLon_and_kwds): # PYCHOK LatLon=LatLon method toNvector (line 91) | def toNvector(self, **Nvector_and_kwds): # PYCHOK Datums.WGS84 class LatLon (line 111) | class LatLon(LatLonNvectorBase, LatLonSphericalBase): method _update (line 119) | def _update(self, updated, *attrs, **setters): # PYCHOK args method alongTrackDistanceTo (line 126) | def alongTrackDistanceTo(self, start, end, radius=R_M, wrap=False): method bearingTo (line 162) | def bearingTo(self, other, **unused): # PYCHOK no cover method crossTrackDistanceTo (line 167) | def crossTrackDistanceTo(self, start, end, radius=R_M, wrap=False): method destination (line 193) | def destination(self, distance, bearing, radius=R_M, height=None): method distanceTo (line 220) | def distanceTo(self, other, radius=R_M, wrap=False): method _gc3 (line 247) | def _gc3(self, start, end, namend, raiser=_point_, wrap=False): method greatCircle (line 262) | def greatCircle(self, bearing): method greatCircleTo (line 283) | def greatCircleTo(self, other, wrap=False): method initialBearingTo (line 304) | def initialBearingTo(self, other, wrap=False, **unused): # raiser=... method intermediateChordTo (line 332) | def intermediateChordTo(self, other, fraction, height=None, wrap=False): method intermediateTo (line 360) | def intermediateTo(self, other, fraction, height=None, wrap=False): method intersection (line 396) | def intersection(self, end1, start2, end2, height=None, wrap=False): method intersection2 (line 408) | def intersection2(self, end1, start2, end2, height=None, wrap=False): method isenclosedBy (line 435) | def isenclosedBy(self, points, wrap=False): method isEnclosedBy (line 482) | def isEnclosedBy(self, points): # PYCHOK no cover method iswithin (line 486) | def iswithin(self, point1, point2, wrap=False): method isWithin (line 527) | def isWithin(self, point1, point2): # PYCHOK no cover method midpointTo (line 531) | def midpointTo(self, other, height=None, fraction=_0_5, wrap=False): method nearestOn (line 559) | def nearestOn(self, point1, point2, height=None, within=True, wrap=Fal... method nearestOn2 (line 616) | def nearestOn2(self, points, **closed_radius_height): # PYCHOK no cover method nearestOn3 (line 626) | def nearestOn3(self, points, closed=False, radius=R_M, height=None, wr... method toCartesian (line 669) | def toCartesian(self, **Cartesian_and_kwds): # PYCHOK Cartesian=Carte... method toNvector (line 685) | def toNvector(self, **Nvector_and_kwds): # PYCHOK signature class Nvector (line 699) | class Nvector(NvectorBase): method sphericalNvector (line 716) | def sphericalNvector(self): method toCartesian (line 721) | def toCartesian(self, **Cartesian_and_kwds): # PYCHOK Cartesian=Carte... method toLatLon (line 739) | def toLatLon(self, **LatLon_and_kwds): # PYCHOK height=None, LatLon=L... method greatCircle (line 758) | def greatCircle(self, bearing): function areaOf (line 785) | def areaOf(points, radius=R_M, wrap=False, polar=False): function intersecant2 (line 841) | def intersecant2(center, circle, point, other, **radius_exact_height_wrap): function intersection (line 876) | def intersection(start1, end1, start2, end2, height=None, wrap=False, function intersection2 (line 893) | def intersection2(start1, end1, start2, end2, height=None, wrap=False, function _intersect3 (line 928) | def _intersect3(start1, end1, start2, end2, height, wrap): function meanOf (line 987) | def meanOf(points, height=None, wrap=False, **LatLon_and_kwds): function nearestOn2 (line 1017) | def nearestOn2(point, points, **closed_radius_height): # PYCHOK no cover function nearestOn3 (line 1028) | def nearestOn3(point, points, closed=False, radius=R_M, height=None, wra... function perimeterOf (line 1063) | def perimeterOf(points, closed=False, radius=R_M, wrap=False): function sumOf (line 1107) | def sumOf(nvectors, Vector=Nvector, h=None, **Vector_kwds): function triangulate (line 1125) | def triangulate(point1, bearing1, point2, bearing2, function trilaterate (line 1155) | def trilaterate(point1, distance1, point2, distance2, point3, distance3,... FILE: pygeodesy/sphericalTrigonometry.py class Cartesian (line 67) | class Cartesian(CartesianSphericalBase): method toLatLon (line 72) | def toLatLon(self, **LatLon_and_kwds): # PYCHOK LatLon=LatLon class LatLon (line 89) | class LatLon(LatLonSphericalBase): method _ab1_ab2_db5 (line 93) | def _ab1_ab2_db5(self, other, wrap): method alongTrackDistanceTo (line 105) | def alongTrackDistanceTo(self, start, end, radius=R_M, wrap=False): method _a_x_b3 (line 137) | def _a_x_b3(self, start, end, radius, wrap): method bearingTo (line 153) | def bearingTo(self, other, wrap=False, raiser=False): # PYCHOK no cover method crossingParallels (line 158) | def crossingParallels(self, other, lat, wrap=False): method crossTrackDistanceTo (line 187) | def crossTrackDistanceTo(self, start, end, radius=R_M, wrap=False): method destination (line 209) | def destination(self, distance, bearing, radius=R_M, height=None): method distanceTo (line 232) | def distanceTo(self, other, radius=R_M, wrap=False): method greatCircle (line 257) | def greatCircle(self, bearing, Vector=Vector3d, **Vector_kwds): method initialBearingTo (line 282) | def initialBearingTo(self, other, wrap=False, raiser=False): method intermediateTo (line 308) | def intermediateTo(self, other, fraction, height=None, wrap=False): method intersection (line 363) | def intersection(self, end1, other, end2, height=None, wrap=False): method intersections2 (line 399) | def intersections2(self, rad1, other, rad2, radius=R_M, eps=_0_0, method isEnclosedBy (line 441) | def isEnclosedBy(self, points): # PYCHOK no cover method isenclosedBy (line 445) | def isenclosedBy(self, points, wrap=False): method midpointTo (line 506) | def midpointTo(self, other, height=None, fraction=_0_5, wrap=False): method nearestOn (line 542) | def nearestOn(self, point1, point2, radius=R_M, **wrap_adjust_limit): method nearestOn2 (line 598) | def nearestOn2(self, points, closed=False, radius=R_M, **options): # ... method nearestOn3 (line 609) | def nearestOn3(self, points, closed=False, radius=R_M, **wrap_adjust_l... method toCartesian (line 644) | def toCartesian(self, **Cartesian_datum_kwds): # PYCHOK Cartesian=Car... method triangle7 (line 661) | def triangle7(self, otherB, otherC, radius=R_M, wrap=False): method triangulate (line 685) | def triangulate(self, bearing1, other, bearing2, **height_wrap): method trilaterate5 (line 703) | def trilaterate5(self, distance1, point2, distance2, point3, distance3, function areaOf (line 761) | def areaOf(points, radius=R_M, wrap=False, polar=False): # was wrap=True function _destination2 (line 832) | def _destination2(a, b, r, t): function _int3d2 (line 852) | def _int3d2(s, end, wrap, _i_, Vector, hs): function _intdot (line 880) | def _intdot(ds, a1, b1, a, b, wrap): function intersecant2 (line 886) | def intersecant2(center, circle, point, other, **radius_exact_height_wrap): function _intersect (line 921) | def _intersect(start1, end1, start2, end2, height=None, wrap=False, # i... function intersection (line 989) | def intersection(start1, end1, start2, end2, height=None, wrap=False, function intersections2 (line 1029) | def intersections2(center1, rad1, center2, rad2, radius=R_M, eps=_0_0, function _intersects2 (line 1082) | def _intersects2(c1, rad1, c2, rad2, radius=R_M, eps=_0_0, # in .ellips... function isPoleEnclosedBy (line 1142) | def isPoleEnclosedBy(points, wrap=False): # PYCHOK no cover function _LL3Tuple (line 1148) | def _LL3Tuple(lat, lon, height, where, LatLon, LatLon_kwds): function meanOf (line 1160) | def meanOf(points, height=None, wrap=False, LatLon=LatLon, **LatLon_kwds): function nearestOn2 (line 1191) | def nearestOn2(point, points, **closed_radius_LatLon_options): # PYCHOK... function nearestOn3 (line 1206) | def nearestOn3(point, points, closed=False, radius=R_M, wrap=False, adju... function perimeterOf (line 1262) | def perimeterOf(points, closed=False, radius=R_M, wrap=True): function triangle7 (line 1306) | def triangle7(latA, lonA, latB, lonB, latC, lonC, radius=R_M, function triangle8_ (line 1341) | def triangle8_(phiA, lamA, phiB, lamB, phiC, lamC, excess=excessAbc_, function _t7Tuple (line 1389) | def _t7Tuple(t, radius): FILE: pygeodesy/streprs.py class _Fmt (line 37) | class _Fmt(str): method __call__ (line 42) | def __call__(self, *name_value_, **name_value): class Fstr (line 60) | class Fstr(str): method __call__ (line 65) | def __call__(self, flt, prec=None, ints=False): method __mod__ (line 73) | def __mod__(self, arg, **unused): class _Sub (line 103) | class _Sub(str): method __call__ (line 107) | def __call__(self, *Classes): class Fmt (line 112) | class Fmt(object): method __init__ (line 150) | def __init__(self): method __call__ (line 156) | def __call__(self, obj, prec=9): method INDEX (line 162) | def INDEX(self, name=NN, i=None, **name_i): method no_convergence (line 169) | def no_convergence(self, _d, *tol, **thresh): method repr_at (line 181) | def repr_at(self, inst, text=NN): function anstr (line 199) | def anstr(name, OKd=_OKd_, sub=_UNDER_): function attrs (line 219) | def attrs(inst, *names, **Nones_True__pairs_kwds): # prec=6, fmt=Fmt.F,... function enstr2 (line 244) | def enstr2(easting, northing, prec, *extras, **wide_dot): function _enstr2m3 (line 282) | def _enstr2m3(estr, nstr, wide=_EN_WIDE): # in .mgrs, .osgr function fstr (line 301) | def fstr(floats, prec=6, fmt=Fmt.F, ints=False, sep=_COMMASPACE_, strepr... function _fstrENH2 (line 331) | def _fstrENH2(inst, prec, m, fmt=Fmt.F): # in .css, .lcc, .utmupsBase function _fstrLL0 (line 342) | def _fstrLL0(inst, prec, toRepr): # in .azimuthal, .css function fstrzs (line 353) | def fstrzs(efstr, ap1z=False): function hstr (line 388) | def hstr(height, prec=2, fmt=Fmt.h, ints=False, m=NN): function instr (line 403) | def instr(inst, *args, **kwds): function lrstrip (line 415) | def lrstrip(txt, lrpairs=_LR_PAIRS): function pairs (line 434) | def pairs(items, prec=6, fmt=Fmt.F, ints=False, sep=_EQUAL_): function _pct (line 460) | def _pct(fmt): function reprs (line 466) | def reprs(objs, prec=6, fmt=Fmt.F, ints=False): function _resolution10 (line 481) | def _resolution10(resolution, Error=ValueError): # in .mgrs, .osgr function _streprs (line 493) | def _streprs(prec, objs, fmt, ints, force, strepr): function strs (line 529) | def strs(objs, prec=6, fmt=Fmt.F, ints=False): function unstr (line 544) | def unstr(where, *args, **kwds_): function _0wd (line 577) | def _0wd(*w_i): # in .osgr, .wgrs function _0wdot (line 583) | def _0wdot(w, f, dot=0): function _0wpF (line 592) | def _0wpF(*w_p_f): # in .dms, .osgr function _xzipairs (line 598) | def _xzipairs(names, values, sep=_COMMASPACE_, fmt=NN, pair_fmt=Fmt.COLON): FILE: pygeodesy/trf.py function _E (line 145) | def _E(epoch): # deleted below function _P (line 152) | def _P(ps, name, _Ps): # deleted below class RefFrame (line 159) | class RefFrame(_NamedEnumItem): method __init__ (line 165) | def __init__(self, epoch, datum=_GRS80, name=NN): method __eq__ (line 190) | def __eq__(self, other): method __lt__ (line 195) | def __lt__(self, other): # for sorting method __matmul__ (line 200) | def __matmul__(self, point): method datum (line 205) | def datum(self): method ellipsoid (line 211) | def ellipsoid(self): method epoch (line 217) | def epoch(self): method toRefFrame (line 222) | def toRefFrame(self, point, reframe2, **epoch_epoch2_name): method toStr (line 245) | def toStr(self, epoch=None, name=NN, **unused): # PYCHOK signature method Xform (line 261) | def Xform(self, reframe2): method Xforms (line 274) | def Xforms(self, inverse=False): method _Xfrom (line 286) | def _Xfrom(self, RFs, inverted): method _Xitems (line 296) | def _Xitems(self, inverse, RFs): # in _eXhaustives, .Xforms class RefFrames (line 308) | class RefFrames(_NamedEnum): method _Lazy (line 312) | def _Lazy(self, epoch, datum=_GRS80, name=NN): class TransformXform (line 359) | class TransformXform(Transform): method __init__ (line 366) | def __init__(self, name=NN, **tx_ty_tz_s_sx_sy_sz): # PYCHOK signature method __eq__ (line 380) | def __eq__(self, other): method __hash__ (line 383) | def __hash__(self): method inverse (line 386) | def inverse(self, **name): method rename (line 399) | def rename(self, name=NN): method toRefFrame (line 410) | def toRefFrame(self, point, **name): # PYCHOK signature method toTransform (line 432) | def toTransform(self, epoch1, **epoch2_inverse): method transform2 (line 452) | def transform2(self, x, y, z, vx=0, vy=0, vz=0, inverse=False, factor=... method velocities (line 503) | def velocities(self, factor=_MM2M, **Vector_and_kwds): method Xform (line 534) | def Xform(self): method Xform (line 540) | def Xform(self, Xform): class TRFXform7Tuple (line 549) | class TRFXform7Tuple(_NamedTuple): method __add__ (line 563) | def __add__(self, other): method __eq__ (line 566) | def __eq__(self, other): method __hash__ (line 570) | def __hash__(self): method __mul__ (line 573) | def __mul__(self, factor): method __neg__ (line 577) | def __neg__(self): method __sub__ (line 580) | def __sub__(self, other): method _add_sub (line 583) | def _add_sub(self, other, p_): method inverse (line 590) | def inverse(self, name=NN): method isunity (line 601) | def isunity(self): class TRFXform (line 607) | class TRFXform(_Named): method __init__ (line 620) | def __init__(self, refName1, refName2, epoch=None, xform=None, method __add__ (line 647) | def __add__(self, other): method __eq__ (line 650) | def __eq__(self, other): method __lt__ (line 658) | def __lt__(self, other): # for sorting method __neg__ (line 663) | def __neg__(self): method __repr__ (line 666) | def __repr__(self): method __str__ (line 669) | def __str__(self): method __sub__ (line 672) | def __sub__(self, other): method _add_sub (line 675) | def _add_sub(self, other, p_, *n1_n2_n): # in _indirects below method _at (line 696) | def _at(self, epoch): method epoch (line 707) | def epoch(self): method epoch (line 713) | def epoch(self, epoch): method epoched (line 724) | def epoched(self): method indirected (line 730) | def indirected(self): method inverse (line 736) | def inverse(self, name=NN): method inversed (line 757) | def inversed(self): method _reframe (line 762) | def _reframe(self, name, datum=_GRS80): method reframe1 (line 772) | def reframe1(self): method reframe2 (line 778) | def reframe2(self): method rename (line 783) | def rename(self, name=NN): method toEpoch (line 793) | def toEpoch(self, epoch): method toHelmert (line 811) | def toHelmert(self, factor=_MM2M): method toRefFrame (line 827) | def toRefFrame(self, point, datum=_GRS80, **epoch_epoch2_name): method toRepr (line 846) | def toRepr(self, **unused): # PYCHOK signature method toStr (line 851) | def toStr(self, epoch=None, **unused): # PYCHOK signature method toTransform (line 860) | def toTransform(self, epoch=None, epoch2=None, inverse=False): function date2epoch (line 888) | def date2epoch(year, month, day): function _direct (line 913) | def _direct(n1, n2): function _Epoch (line 920) | def _Epoch(e, **kwds): function epoch2date (line 926) | def epoch2date(epoch): function _eXhaustives (line 949) | def _eXhaustives(n1, n2): function _indirects (line 971) | def _indirects(n1, n2): function _n1_n2_n3 (line 996) | def _n1_n2_n3(X1, X2): function _n_pop (line 1004) | def _n_pop(X): function _reframe (line 1017) | def _reframe(**name_reframe): function _stref (line 1028) | def _stref(**name_refname): function _sumstr (line 1037) | def _sumstr(name1, name2, p_): function _toRefFrame (line 1048) | def _toRefFrame(point, reframe2, reframe=None, epoch=None, function _toTransform0 (line 1092) | def _toTransform0(n1, e1, n2, e2, **indirect_inverse): function _toTransforms (line 1108) | def _toTransforms(n1, e1, n2, e2, indirect=True, inverse=True, exhaust=F... function trfTransform0 (line 1149) | def trfTransform0(reframe, reframe2, epoch=None, epoch2=None, indirect=T... function trfTransforms (line 1162) | def trfTransforms(reframe, reframe2, epoch=None, epoch2=None, indirect=T... function _trfT0s (line 1191) | def _trfT0s(_toT0s, reframe, reframe2, epoch, epoch2, **indirect_inverse... function trfXform (line 1201) | def trfXform(reframe1, reframe2, epoch=None, xform=None, rates=None, rai... function _trfX (line 1239) | def _trfX(n1, n2, raiser=True, **epoch_xform_rates): function _X (line 1299) | def _X(*ps): # deleted below function _R (line 1303) | def _R(*ps): # deleted below function _main (line 1737) | def _main(): FILE: pygeodesy/triaxials/bases.py class Conformal5Tuple (line 76) | class Conformal5Tuple(_NamedTuple): # see .Forward4Tuple method __new__ (line 84) | def __new__(cls, x, y, z=INT0, scale=NAN, llk=None, **kwds): # **iter... class _LLK (line 89) | class _LLK(str): method __init__ (line 92) | def __init__(self, llk): # aka C++ alt class LLK (line 97) | class LLK(object): method __getitem__ (line 121) | def __getitem__(self, name): method get (line 129) | def get(self, name, dflt=None): method items (line 135) | def items(self): method keys (line 142) | def keys(self): method values (line 148) | def values(self): function _HeightINT0 (line 159) | def _HeightINT0(h): class _UnOrderedTriaxialBase (line 163) | class _UnOrderedTriaxialBase(_NamedEnumItem): method __init__ (line 169) | def __init__(self, a_triaxial, b=None, c=None, **name): method __repr__ (line 204) | def __repr__(self): method a (line 213) | def a(self): method a2 (line 220) | def a2(self): method _a2b2 (line 226) | def _a2b2(self): method _a2_b2 (line 234) | def _a2_b2(self): method abc3 (line 241) | def abc3(self): # in geed3solve._a12d method _a2b2c23 (line 247) | def _a2b2c23(self): # in .triaxials.triaxial3 method _a2c2 (line 253) | def _a2c2(self): method area (line 261) | def area(self): method areaKT (line 266) | def areaKT(self, *p): method area_p (line 281) | def area_p(self, p=1.6075): method areaRG (line 286) | def areaRG(self): method b (line 296) | def b(self): method b2 (line 303) | def b2(self): method _b2_a2 (line 309) | def _b2_a2(self): method _b2c2 (line 316) | def _b2c2(self): method c (line 324) | def c(self): method c2 (line 331) | def c2(self): method _c2_a2 (line 337) | def _c2_a2(self): method _c2_b2 (line 344) | def _c2_b2(self): method e2ab (line 351) | def e2ab(self): method e2ac (line 359) | def e2ac(self): method e2bc (line 367) | def e2bc(self): method ellipse5 (line 374) | def ellipse5(self, lat): method hartzell4 (line 405) | def hartzell4(self, pov, los=False, **name): method height4 (line 413) | def height4(self, x_xyz, y=None, z=None, normal=True, eps=EPS, **name): method isFlat (line 421) | def isFlat(self): method isOblate (line 429) | def isOblate(self): method isOrdered (line 435) | def isOrdered(self): method isProlate (line 442) | def isProlate(self): method isSpherical (line 449) | def isSpherical(self): method _norm2 (line 455) | def _norm2(self, s, c, *a): method normal3d (line 464) | def normal3d(self, x_xyz, y=None, z=None, length=_1_0): method normal4 (line 496) | def normal4(self, x_xyz, y=None, z=None, height=0, normal=True): method _order3 (line 535) | def _order3(self, *abc, **reverse): # reverse=False method _order3d (line 544) | def _order3d(self, v, **reverse): # reverse=False method _ordered4 (line 553) | def _ordered4(self): method _order_ijk (line 582) | def _order_ijk(self, reverse=False): method perimeter4ab (line 588) | def perimeter4ab(self): method perimeter4ac (line 594) | def perimeter4ac(self): method perimeter4bc (line 600) | def perimeter4bc(self): method R2 (line 606) | def R2(self): method R3 (line 615) | def R3(self): method _radialTo3 (line 623) | def _radialTo3(self, sbeta, cbeta, somega, comega): method sideOf (line 643) | def sideOf(self, x_xyz, y=None, z=None, eps=EPS4): method _sideOn (line 664) | def _sideOn(self, v, eps=_EPS2e4): method toEllipsoid (line 671) | def toEllipsoid(self, **name): method toStr (line 695) | def toStr(self, prec=9, terse=-3, **name): # PYCHOK signature method unOrdered (line 728) | def unOrdered(self): method volume (line 734) | def volume(self): class _OrderedTriaxialBase (line 741) | class _OrderedTriaxialBase(_UnOrderedTriaxialBase): method __init__ (line 746) | def __init__(self, a_triaxial, b=None, c=None, **name): method _a2b2_a2c2 (line 764) | def _a2b2_a2c2(self): method area (line 773) | def area(self): method area21k (line 784) | def area21k(self): method _areax (line 805) | def _areax(self): method _k2_kp2E (line 813) | def _k2_kp2E(self): method _radialTo3 (line 826) | def _radialTo3(self, sbeta, cbeta, somega, comega): class _Triaxial3Base (line 848) | class _Triaxial3Base(_OrderedTriaxialBase): method e2 (line 855) | def e2(self): method _init_abc3_e2_k2_kp2 (line 864) | def _init_abc3_e2_k2_kp2(self, b, e2, k2, kp2, **name): method isBiaxial (line 887) | def isBiaxial(self): method isOblate (line 893) | def isOblate(self): method isProlate (line 899) | def isProlate(self): method _k_kp (line 905) | def _k_kp(self): method k2 (line 911) | def k2(self): method _k2_kp2 (line 918) | def _k2_kp2(self): method kp2 (line 930) | def kp2(self): method _lcc23 (line 937) | def _lcc23(self): method Lon0 (line 941) | def Lon0(self): method Lon0 (line 948) | def Lon0(self, lon0): method _xE (line 955) | def _xE(self): method _xyE (line 960) | def _xyE(self, e2, k2, kp2): method _yE (line 973) | def _yE(self): class TriaxialError (line 979) | class TriaxialError(_ValueError): class _TriaxialsBase (line 985) | class _TriaxialsBase(_NamedEnum): method _Lazy (line 992) | def _Lazy(self, *abc, **name): method _assert (line 997) | def _assert(self): # PYCHOK signature function _getitems (line 1028) | def _getitems(items, *indices): function _hypot2_1 (line 1038) | def _hypot2_1(x, y, z=0): function _otherV3d_ (line 1045) | def _otherV3d_(x_xyz, y, z, **name): function _over0 (line 1052) | def _over0(p, q): function _over02 (line 1058) | def _over02(p, q): function _sqrt0 (line 1064) | def _sqrt0(x): FILE: pygeodesy/triaxials/conformal3.py class BetOmgGam5Tuple (line 52) | class BetOmgGam5Tuple(_Ang3Tuple): method __new__ (line 60) | def __new__(cls, bet, omg, gam, scale=NAN, llk=None, unit=None, **kwds... class Conformal3 (line 66) | class Conformal3(_Triaxial3Base): method _a_b (line 73) | def _a_b(self): method _a2_b (line 77) | def _a2_b(self): method _b_a (line 81) | def _b_a(self): method _b_c (line 85) | def _b_c(self): method _c_b (line 89) | def _c_b(self): method _c2_b (line 93) | def _c2_b(self): method _C3S (line 97) | def _C3S(self): method equi3Sphere (line 102) | def equi3Sphere(self, x, y, **name): method forwardBetOmg (line 166) | def forwardBetOmg(self, bet, omg, M=False, **unit_name): method forwardOther (line 181) | def forwardOther(self, other, bet, omg, M=False, **unit_name): method forwardSphere3 (line 206) | def forwardSphere3(self, bet, omg, M=False, **unit_name): method _invScale (line 235) | def _invScale(self, bet, omg): method reverseBetOmg (line 239) | def reverseBetOmg(self, x_cf, y=None, M=False, **unit_name): method reverseOther (line 258) | def reverseOther(self, other, beto, omgo, M=False, **unit_name): method reverseSphere (line 278) | def reverseSphere(self, x_ct, y=None, z=None, dir3d=None, M=False, **u... method _sphScale (line 307) | def _sphScale(self, ma, mb): method _sphScale_m (line 313) | def _sphScale_m(self): method _x (line 333) | def _x(self, omg): # degrees? method xyQ2 (line 346) | def xyQ2(self): method _y (line 353) | def _y(self, bet): # degrees? class Conformal3B (line 365) | class Conformal3B(Conformal3): method __init__ (line 371) | def __init__(self, b, e2=_0_0, k2=_1_0, kp2=_0_0, **name): class Conformal3Sphere (line 382) | class Conformal3Sphere(Triaxial3B): # note C{Triaxial3}! method __init__ (line 387) | def __init__(self, radius, k2=_1_0, kp2=_0_0, **name): function _bet_omg_name (line 397) | def _bet_omg_name(bet, omg, unit=Radians, **name): function _cf2en (line 404) | def _cf2en(x_cf, y): function _F (line 411) | def _F(eF, phi): # -> float function _invF (line 424) | def _invF(eF, x): # -> Ang function _invPi (line 441) | def _invPi(eF, x): # -> Ang function _invRy2 (line 461) | def _invRy2(eF, eF_c, x): function _invScale (line 476) | def _invScale(triax, bet, omg): function _Neg (line 482) | def _Neg(ang): function _Pi (line 486) | def _Pi(eF, phi): # -> float function _root4 (line 499) | def _root4(_fp2, z, x, xa=_0_0, xb=PI_2, xscale=1, zscale=1, s=1, tol=EP... FILE: pygeodesy/triaxials/triaxial3.py class BetOmgAlp5Tuple (line 71) | class BetOmgAlp5Tuple(_Ang3Tuple): class Cartesian5Tuple (line 81) | class Cartesian5Tuple(Vector4Tuple): method __new__ (line 90) | def __new__(cls, x, y, z, h=0, llk=None, **kwds): # **iteration_name class _Fp2 (line 95) | class _Fp2(object): method __init__ (line 98) | def __init__(self, rs, ls, n=1): method __call__ (line 103) | def __call__(self, p): class PhiLamZet5Tuple (line 123) | class PhiLamZet5Tuple(_Ang3Tuple): class Triaxial3 (line 133) | class Triaxial3(_Triaxial3Base): method _cardinal2 (line 139) | def _cardinal2(self, v, mer, llk): # cardinaldir method forwardBetOmg (line 164) | def forwardBetOmg(self, bet, omg, height=0, **unit_name): # elliptocart2 method forwardBetaOmega_ (line 185) | def forwardBetaOmega_(self, sbeta, cbeta, somega, comega, **name): method forwardBetOmgAlp2 (line 190) | def forwardBetOmgAlp2(self, bet, omg, alp, height=0, **unit_name): # ... method forwardCartesian (line 263) | def forwardCartesian(self, x_ct, y=None, z=None, normal=True, **eps_ll... method forwardLatLon (line 292) | def forwardLatLon(self, lat, lon, height=0, llk=LLK.ELLIPSOIDAL, **uni... method forwardPhiLam (line 312) | def forwardPhiLam(self, phi, lam, height=0, llk=LLK.GEODETIC, **unit_n... method forwardPhiLamZet2 (line 333) | def forwardPhiLamZet2(self, phi, lam, zet, height=0, llk=LLK.GEODETIC,... method _meridian (line 392) | def _meridian(self, lam, llk): method _meridian2 (line 401) | def _meridian2(self, v, lam, llk): method normed2 (line 407) | def normed2(self, x_ct, y=None, z=None, dir3d=None, **llk_name): # El... method reverseBetOmg (line 445) | def reverseBetOmg(self, x_ct, y=None, z=None, **llk_name): # Cartesia... method reverseBetOmgAlp (line 483) | def reverseBetOmgAlp(self, x_ct, y=None, z=None, dir3d=None, **llk_nam... method _reverseBetOmgAlp3 (line 504) | def _reverseBetOmgAlp3(self, v, dir3d, *a_b_c, **name): # cart2toelli... method reverseCartesian (line 564) | def reverseCartesian(self, x_ct, y=None, z=None, height=0, normal=True... method reverseLatLon (line 595) | def reverseLatLon(self, x_ct, y=None, z=None, **llk_name): # cart2toany method reversePhiLam (line 618) | def reversePhiLam(self, x_ct, y=None, z=None, **llk_name): # cart2tog... method reversePhiLamZet (line 636) | def reversePhiLamZet(self, x_ct, y=None, z=None, dir3d=None, **llk_nam... method random2 (line 676) | def random2(self, llk=LLK.ELLIPSOIDAL, both=False, _rand=random): method _toHeight2 (line 720) | def _toHeight2(self, v, h, normal=True): method toOther (line 729) | def toOther(self, lat, lon, llk1=LLK.GEODETIC, llk2=LLK.GEODETIC, **un... method toTriaxial5 (line 754) | def toTriaxial5(self, x_ct, y=None, z=None, **triaxial_h_llk_name): #... method _ZTOL (line 798) | def _ZTOL(self): method _ztol (line 801) | def _ztol(self, v): class Triaxial3B (line 806) | class Triaxial3B(Triaxial3): method __init__ (line 811) | def __init__(self, b, e2=_0_0, k2=_1_0, kp2=_0_0, **name): function _cubic (line 819) | def _cubic(rs, rt, l0, l1): # Cartesian3.cubic function _d_t (line 852) | def _d_t(triax, llk): function _h_llk_unit_name (line 866) | def _h_llk_unit_name(height, h=None, llk=LLK.ELLIPSOIDAL, unit=Radians, ... function _solve (line 878) | def _solve(_fp2, p, pscale, **n): function _txtz2 (line 899) | def _txtz2(cb, so, k, kp): function _v_h_llk_name (line 905) | def _v_h_llk_name(x_ct, y=None, z=None, **h_llk_name): function _v_h_llk_name_NOIDAL (line 921) | def _v_h_llk_name_NOIDAL(x_ct, y, z, **h_llk_name): class Triaxial3s (line 932) | class Triaxial3s(_TriaxialsBase): FILE: pygeodesy/triaxials/triaxial5.py class _NamedTupleToX (line 72) | class _NamedTupleToX(_NamedTupleTo): # in .testNamedTuples method _toDegrees (line 76) | def _toDegrees(self, name, **toDMS_kwds): method _toRadians (line 81) | def _toRadians(self, name): method _toX3U (line 86) | def _toX3U(self, _X3, U, name, a, b, *c, **kwds): class BetaOmega2Tuple (line 94) | class BetaOmega2Tuple(_NamedTupleToX): method toDegrees (line 102) | def toDegrees(self, name=NN, **toDMS_kwds): method toRadians (line 114) | def toRadians(self, **name): class BetaOmega3Tuple (line 125) | class BetaOmega3Tuple(_NamedTupleToX): method toDegrees (line 135) | def toDegrees(self, name=NN, **toDMS_kwds): method toRadians (line 147) | def toRadians(self, **name): method to2Tuple (line 157) | def to2Tuple(self, **name): class Conformal2Tuple (line 165) | class Conformal2Tuple(_NamedTupleToX): method toDegrees (line 172) | def toDegrees(self, name=NN, **toDMS_kwds): method toRadians (line 183) | def toRadians(self, **name): method to5Tuple (line 192) | def to5Tuple(self, b_conformal, **z_scale_name): class Triaxial_ (line 211) | class Triaxial_(_UnOrderedTriaxialBase): class Triaxial (line 231) | class Triaxial(_OrderedTriaxialBase): method forwardBetaOmega (line 239) | def forwardBetaOmega(self, beta, omega, height=0, **unit_name): method forwardBetaOmega_ (line 276) | def forwardBetaOmega_(self, sbeta, cbeta, somega, comega, **name): method forwardCartesian (line 298) | def forwardCartesian(self, x_xyz, y=None, z=None, normal=True, **eps_n... method forwardLatLon (line 318) | def forwardLatLon(self, lat, lon, height=0, **unit_name): method forwardLatLon_ (line 337) | def forwardLatLon_(self, slat, clat, slon, clon, height=0, **name): method _forwardLatLon3 (line 357) | def _forwardLatLon3(self, height, name, sa, ca, sb, cb): # name alway... method _Height (line 372) | def _Height(self, height): method reverseBetaOmega (line 377) | def reverseBetaOmega(self, x_xyz, y=None, z=None, **name): method reverseCartesian (line 400) | def reverseCartesian(self, x_xyz, y=None, z=None, height=0, normal=Tru... method reverseLatLon (line 434) | def reverseLatLon(self, x_xyz, y=None, z=None, **name): class TriaxialB (line 460) | class TriaxialB(_Triaxial3Base): method __init__ (line 465) | def __init__(self, b, e2=_0_0, k2=_1_0, kp2=_0_0, **name): class Conformal (line 486) | class Conformal(Triaxial): method _a2_b (line 511) | def _a2_b(self): method _c2_b (line 515) | def _c2_b(self): method x (line 518) | def x(self, omega, unit=Radians): method _x (line 530) | def _x(self, s, c, a2_b_): method _xE (line 537) | def _xE(self): method xR (line 544) | def xR(self, omega, unit=Radians): method xR_ (line 554) | def xR_(self, somega, comega): method xy (line 564) | def xy(self, beta, omega, **unit_name): method xyQ2 (line 581) | def xyQ2(self): method xyQR2 (line 590) | def xyQR2(self): method xyR2 (line 598) | def xyR2(self, beta, omega, **unit_name): method xyR2_ (line 612) | def xyR2_(self, sbeta, cbeta, somega, comega, **name): method y (line 627) | def y(self, beta, unit=Radians): method _y (line 639) | def _y(self, s, c, c2_b_): method _yE (line 646) | def _yE(self): method yR (line 653) | def yR(self, beta, unit=Radians): method yR_ (line 663) | def yR_(self, sbeta, cbeta): class ConformalSphere (line 674) | class ConformalSphere(Conformal): method __init__ (line 681) | def __init__(self, radius_conformal, ab=0, bc=0, **name): method ab (line 721) | def ab(self): method _a2b2 (line 727) | def _a2b2(self): method _a2c2 (line 734) | def _a2c2(self): method bc (line 740) | def bc(self): method _b2c2 (line 746) | def _b2c2(self): method radius (line 753) | def radius(self): function _hartzell3 (line 759) | def _hartzell3(pov, los, Tun): # in .Ellipsoid.hartzell4, .formy.hartzell function hartzell4 (line 814) | def hartzell4(pov, los=False, tri_biax=_WGS84, **name): function height4 (line 853) | def height4(x_xyz, y=None, z=None, tri_biax=_WGS84, normal=True, eps=EPS... function _ordered (line 911) | def _ordered(a, b, c): function _plumbTo3 (line 918) | def _plumbTo3(px, py, E, eps=EPS): # in .ellipsoids.Ellipsoid.height4 function _plumbTo4 (line 956) | def _plumbTo4(x, y, a, b, eps=EPS): function _plumbTo5 (line 1010) | def _plumbTo5(x, y, z, Tun, eps=EPS): # in .testTriaxials function _reverseLatLon3 (line 1077) | def _reverseLatLon3(s, atan2_, v, forward_): function _rootNd (line 1086) | def _rootNd(r, s, u, v, w, g, eps=EPS0): function _tri_biaxial (line 1118) | def _tri_biaxial(tri_biax, where): function _validate (line 1130) | def _validate(a, b, c, d, T, x, y, z, val): class Triaxials (line 1148) | class Triaxials(_TriaxialsBase): FILE: pygeodesy/units.py class Float_ (line 34) | class Float_(Float): method __new__ (line 37) | def __new__(cls, arg=None, name=NN, low=EPS, high=None, **Error_name_a... class Int_ (line 57) | class Int_(Int): method __new__ (line 60) | def __new__(cls, arg=None, name=NN, low=0, high=None, **Error_name_arg): class Bool (line 80) | class Bool(Int, _NamedUnit): method __new__ (line 86) | def __new__(cls, arg=None, name=NN, Error=UnitError, **name_arg): method __bool__ (line 112) | def __bool__(self): # PYCHOK Python 3+ method toRepr (line 117) | def toRepr(self, std=False, **unused): # PYCHOK **unused method toStr (line 129) | def toStr(self, **unused): # PYCHOK **unused class Band (line 135) | class Band(Str): method __new__ (line 138) | def __new__(cls, arg=None, name=_band_, **Error_name_arg): class Degrees (line 144) | class Degrees(Float): method __new__ (line 151) | def __new__(cls, arg=None, name=_degrees_, suffix=_NSEW_, clip=0, wrap... method toDegrees (line 184) | def toDegrees(self): method toRadians (line 189) | def toRadians(self): method toRepr (line 194) | def toRepr(self, std=False, **prec_fmt_ints): # PYCHOK prec=8, ... method toStr (line 205) | def toStr(self, prec=None, fmt=F__F_, ints=False, **s_D_M_S): # PYCHO... class Degrees_ (line 218) | class Degrees_(Degrees): method __new__ (line 221) | def __new__(cls, arg=None, name=_degrees_, low=None, high=None, **suff... class Degrees2 (line 242) | class Degrees2(Float): method __new__ (line 245) | def __new__(cls, arg=None, name=_degrees2_, **Error_name_arg): class Radians (line 251) | class Radians(Float): method __new__ (line 254) | def __new__(cls, arg=None, name=_radians_, suffix=_NSEW_, clip=0, Erro... method toDegrees (line 281) | def toDegrees(self): method toRadians (line 286) | def toRadians(self): method toRepr (line 291) | def toRepr(self, std=False, **prec_fmt_ints): # PYCHOK prec=8, ... method toStr (line 302) | def toStr(self, prec=8, fmt=F__F, ints=False): # PYCHOK prec=8, ... class Radians_ (line 310) | class Radians_(Radians): method __new__ (line 313) | def __new__(cls, arg=None, name=_radians_, low=_0_0, high=PI2, **suffi... class Radians2 (line 334) | class Radians2(Float_): method __new__ (line 337) | def __new__(cls, arg=None, name=_radians2_, **Error_name_arg): function _Degrees_new (line 343) | def _Degrees_new(cls, **arg_name_suffix_clip_Error_name_arg): class Azimuth (line 349) | class Azimuth(Degrees): method __new__ (line 355) | def __new__(cls, arg=None, name=_azimuth_, **clip_Error_name_arg): class Bearing (line 362) | class Bearing(Degrees): method __new__ (line 368) | def __new__(cls, arg=None, name=_bearing_, **clip_Error_name_arg): class Bearing_ (line 374) | class Bearing_(Radians): method __new__ (line 377) | def __new__(cls, arg=None, **name_clip_Error_name_arg): class Distance (line 384) | class Distance(Float): method __new__ (line 387) | def __new__(cls, arg=None, name=_distance_, **Error_name_arg): class Distance_ (line 393) | class Distance_(Float_): method __new__ (line 396) | def __new__(cls, arg=None, name=_distance_, **low_high_Error_name_arg): class _EasNorBase (line 402) | class _EasNorBase(Float): method __new__ (line 405) | def __new__(cls, arg, name, falsed, high, **Error_name_arg): class Easting (line 417) | class Easting(_EasNorBase): method __new__ (line 420) | def __new__(cls, arg=None, name=_easting_, falsed=False, high=None, **... class Epoch (line 436) | class Epoch(Float_): # in .ellipsoidalBase, .trf method __new__ (line 442) | def __new__(cls, arg=None, name=_epoch_, low=1900, high=9999, Error=TR... method toRepr (line 450) | def toRepr(self, prec=3, std=False, **unused): # PYCHOK fmt=Fmt.F, in... method toStr (line 460) | def toStr(self, prec=3, **unused): # PYCHOK fmt=Fmt.F, nts=True class Feet (line 470) | class Feet(Float): method __new__ (line 473) | def __new__(cls, arg=None, name=_feet_, **Error_name_arg): class FIx (line 479) | class FIx(Float_): method __new__ (line 487) | def __new__(cls, fi, fin=None, Error=UnitError, **name): method fin (line 517) | def fin(self): method fractional (line 522) | def fractional(self, points, wrap=None, **LatLon_or_Vector_and_kwds): function _fi_j2 (line 548) | def _fi_j2(f, n): # PYCHOK in .ellipsoidalBaseDI, .vector3d class Height (line 556) | class Height(Float): # here to avoid circular import method __new__ (line 559) | def __new__(cls, arg=None, name=_height_, **Error_name_arg): class Height_ (line 565) | class Height_(Float_): # here to avoid circular import method __new__ (line 568) | def __new__(cls, arg=None, name=_height_, **low_high_Error_name_arg): class HeightX (line 574) | class HeightX(Height): function _heigHt (line 581) | def _heigHt(inst, height): class Lam (line 587) | class Lam(Radians): method __new__ (line 590) | def __new__(cls, arg=None, name=_lam_, clip=PI, **Error_name_arg): class Lamd (line 596) | class Lamd(Lam): method __new__ (line 599) | def __new__(cls, arg=None, name=_lon_, clip=180, **Error_name_arg): class Lat (line 606) | class Lat(Degrees): method __new__ (line 612) | def __new__(cls, arg=None, name=_lat_, clip=90, **Error_name_arg): class Lat_ (line 618) | class Lat_(Degrees_): method __new__ (line 624) | def __new__(cls, arg=None, name=_lat_, low=-90, high=90, **Error_name_... function _Lat0 (line 630) | def _Lat0(lat): # in .ellipsods and .triaxials.bases class Lon (line 636) | class Lon(Degrees): method __new__ (line 642) | def __new__(cls, arg=None, name=_lon_, clip=180, **Error_name_arg): class Lon_ (line 648) | class Lon_(Degrees_): method __new__ (line 654) | def __new__(cls, arg=None, name=_lon_, low=-180, high=180, **Error_nam... class Meter (line 660) | class Meter(Float): method __new__ (line 663) | def __new__(cls, arg=None, name=_meter_, **Error_name_arg): method __repr__ (line 668) | def __repr__(self): class Meter_ (line 688) | class Meter_(Float_): method __new__ (line 691) | def __new__(cls, arg=None, name=_meter_, low=_0_0, **high_Error_name_a... class Meter2 (line 697) | class Meter2(Float_): method __new__ (line 700) | def __new__(cls, arg=None, name=_meter2_, **Error_name_arg): class Meter3 (line 706) | class Meter3(Float_): method __new__ (line 709) | def __new__(cls, arg=None, name='meter3', **Error_name_arg): class Northing (line 715) | class Northing(_EasNorBase): method __new__ (line 718) | def __new__(cls, arg=None, name=_northing_, falsed=False, high=None, *... class Number_ (line 734) | class Number_(Int_): method __new__ (line 737) | def __new__(cls, arg=None, name=_number_, **low_high_Error_name_arg): class Phi (line 743) | class Phi(Radians): method __new__ (line 746) | def __new__(cls, arg=None, name=_phi_, clip=PI_2, **Error_name_arg): class Phid (line 752) | class Phid(Phi): method __new__ (line 755) | def __new__(cls, arg=None, name=_lat_, clip=90, **Error_name_arg): class Precision_ (line 762) | class Precision_(Int_): method __new__ (line 765) | def __new__(cls, arg=None, name=_precision_, **low_high_Error_name_arg): class Radius_ (line 771) | class Radius_(Float_): method __new__ (line 774) | def __new__(cls, arg=None, name=_radius_, **low_high_Error_name_arg): class Scalar (line 780) | class Scalar(Float): method __new__ (line 783) | def __new__(cls, arg=None, name=_scalar_, **Error_name_arg): class Scalar_ (line 789) | class Scalar_(Float_): method __new__ (line 792) | def __new__(cls, arg=None, name=_scalar_, low=_0_0, **high_Error_name_... class Zone (line 798) | class Zone(Int): method __new__ (line 801) | def __new__(cls, arg=None, name=_zone_, **Error_name_arg): function _isDegrees (line 815) | def _isDegrees(obj, iscalar=True): function _isHeight (line 820) | def _isHeight(obj, iscalar=True): function _isMeter (line 825) | def _isMeter(obj, iscalar=True): function _isRadians (line 830) | def _isRadians(obj, iscalar=True): function _isRadius (line 835) | def _isRadius(obj, iscalar=True): function _isScalar (line 840) | def _isScalar(obj, iscalar=True): function _toUnit (line 845) | def _toUnit(Unit, arg, name=NN, **Error): function _xlimits (line 854) | def _xlimits(arg, low, high, g=False): function _std_repr (line 870) | def _std_repr(*Classes): FILE: pygeodesy/unitsBase.py class _NamedUnit (line 23) | class _NamedUnit(_Named): method __new__ (line 29) | def __new__(cls, typ, arg, name, Error=UnitError, **name_arg): method _arg_name_arg2 (line 43) | def _arg_name_arg2(arg, name=NN, name__=None, **name_arg): # in .units method _Error (line 58) | def _Error(cls, arg, name, Error=UnitError, suffix=NN, # unused method std_repr (line 80) | def std_repr(self): method std_repr (line 86) | def std_repr(self, std): method _toRepr (line 91) | def _toRepr(self, value): method units (line 98) | def units(self): method units (line 106) | def units(self, units): class Float (line 112) | class Float(float, _NamedUnit): method __new__ (line 117) | def __new__(cls, arg=None, name=NN, **Error_name_arg): method __repr__ (line 132) | def __repr__(self): # to avoid MRO(float) method __str__ (line 144) | def __str__(self): # to avoid MRO(float) method isneg0 (line 159) | def isneg0(self): method toRepr (line 164) | def toRepr(self, std=False, **prec_fmt_ints): # PYCHOK prec=8, ... method toStr (line 178) | def toStr(self, prec=12, fmt=Fmt.g, ints=False): # PYCHOK prec=8, ... class Int (line 187) | class Int(int, _NamedUnit): method __new__ (line 192) | def __new__(cls, arg=None, name=NN, **Error_name_arg): method __repr__ (line 207) | def __repr__(self): # to avoid MRO(int) method __str__ (line 219) | def __str__(self): # to avoid MRO(int) method toRepr (line 224) | def toRepr(self, std=False, **unused): # PYCHOK **unused method toStr (line 235) | def toStr(self, **unused): # PYCHOK **unused class Radius (line 245) | class Radius(Float): method __new__ (line 248) | def __new__(cls, arg=None, name=_radius_, **Error_name_arg): class Str (line 254) | class Str(str, _NamedUnit): method __new__ (line 259) | def __new__(cls, arg=None, name=NN, **Error_name_arg): method __repr__ (line 277) | def __repr__(self): method __str__ (line 289) | def __str__(self): method join_ (line 294) | def join_(self, *args, **name_Error): method toRepr (line 306) | def toRepr(self, std=False, **unused): # PYCHOK **unused method toStr (line 319) | def toStr(self, **unused): # PYCHOK **unused function _xUnit (line 335) | def _xUnit(units, Base): # PYCHOK in .frechet, .hausdorff function _xUnits (line 343) | def _xUnits(units, Base=_NamedUnit): # in .frechet, .hausdorff FILE: pygeodesy/ups.py class UPSError (line 59) | class UPSError(_ValueError): class Ups (line 65) | class Ups(UtmUpsBase): method __init__ (line 75) | def __init__(self, zone=0, pole=_N_, easting=_Falsing, # PYCHOK expected method __eq__ (line 118) | def __eq__(self, other): method band (line 127) | def band(self): method band (line 135) | def band(self, band): method falsed2 (line 146) | def falsed2(self): method parse (line 152) | def parse(self, strUPS, **name): method parseUPS (line 168) | def parseUPS(self, strUPS): # PYCHOK no cover method pole (line 173) | def pole(self): method rescale0 (line 178) | def rescale0(self, lat, scale0=_K0_UPS): method toLatLon (line 198) | def toLatLon(self, LatLon=None, unfalse=True, **LatLon_kwds): method _toLLEB (line 222) | def _toLLEB(self, unfalse=True): # PYCHOK signature method toRepr (line 242) | def toRepr(self, prec=0, fmt=Fmt.SQUARE, sep=_COMMASPACE_, B=False, cs... method toStr (line 269) | def toStr(self, prec=0, sep=_SPACE_, B=False, cs=False): # PYCHOK exp... method toUps (line 295) | def toUps(self, pole=NN, **unused): method toUtm (line 311) | def toUtm(self, zone, falsed=True, **unused): method zone (line 328) | def zone(self): class _Ups_K1 (line 335) | class _Ups_K1(Ups): function parseUPS5 (line 341) | def parseUPS5(strUPS, datum=_WGS84, Ups=Ups, falsed=True, **name): function _scale (line 370) | def _scale(E, rho, tau): function _toBand (line 376) | def _toBand(lat, lon): # see utm._toBand function toUps8 (line 382) | def toUps8(latlon, lon=None, datum=None, Ups=Ups, pole=NN, function upsZoneBand5 (line 468) | def upsZoneBand5(lat, lon, strict=True, **name): FILE: pygeodesy/utily.py function _abs1nan (line 60) | def _abs1nan(x): function acos1 (line 66) | def acos1(x): function acre2ha (line 72) | def acre2ha(acres): function acre2m2 (line 84) | def acre2m2(acres): function agdf (line 96) | def agdf(phi): function asin1 (line 109) | def asin1(x): function atan1 (line 115) | def atan1(y, x=_1_0): function atan1d (line 122) | def atan1d(y, x=_1_0): function _atan1u (line 131) | def _atan1u(y, x, _2u): function atan2b (line 145) | def atan2b(y, x): function atan2d (line 156) | def atan2d(y, x, reverse=False): function atan2p (line 167) | def atan2p(y, x): # in .fmath.polar2 function _azireversed (line 178) | def _azireversed(azi): # in .rhumb.bases function chain2m (line 184) | def chain2m(chains): function circle4 (line 196) | def circle4(earth, lat): function _circle4radius (line 216) | def _circle4radius(earth, lat=0, **radius): function cot (line 223) | def cot(rad, **raiser_kwds): function cot_ (line 241) | def cot_(*rads, **raiser_kwds): function cotd (line 257) | def cotd(deg, **raiser_kwds): function cotd_ (line 275) | def cotd_(*degs, **raiser_kwds): function _cotu (line 291) | def _cotu(s, c): function degrees90 (line 297) | def degrees90(rad): function degrees180 (line 307) | def degrees180(rad): function degrees360 (line 317) | def degrees360(rad): function degrees2grades (line 327) | def degrees2grades(deg): function degrees2m (line 337) | def degrees2m(deg, earth=R_M, lat=0, **radius): function fathom2m (line 362) | def fathom2m(fathoms): function ft2m (line 377) | def ft2m(feet, usurvey=False, pied=False, india=False, fuss=False): function furlong2m (line 398) | def furlong2m(furlongs): function gdf (line 410) | def gdf(psi): function grades (line 423) | def grades(rad): function grades400 (line 433) | def grades400(rad): function grades2degrees (line 443) | def grades2degrees(gon): function grades2radians (line 453) | def grades2radians(gon): function ha2acre (line 463) | def ha2acre(ha): function ha2m2 (line 475) | def ha2m2(ha): function hav (line 487) | def hav(rad): function km2m (line 497) | def km2m(km): function _loneg (line 509) | def _loneg(lon): function m2acre (line 515) | def m2acre(meter2): function m2chain (line 527) | def m2chain(meter): function m2degrees (line 539) | def m2degrees(distance, earth=R_M, lat=0, **radius): function m2fathom (line 563) | def m2fathom(meter): function m2ft (line 578) | def m2ft(meter, usurvey=False, pied=False, india=False, fuss=False): function m2furlong (line 601) | def m2furlong(meter): function m2ha (line 613) | def m2ha(meter2): function m2km (line 625) | def m2km(meter): function m2NM (line 637) | def m2NM(meter): function _m2rad (line 649) | def _m2rad(distance, earth, lat, **radius): function m2radians (line 657) | def m2radians(distance, earth=R_M, lat=0, **radius): function m2SM (line 681) | def m2SM(meter): function m2toise (line 693) | def m2toise(meter): function m2yard (line 708) | def m2yard(meter, imperial=False): function NM2m (line 723) | def NM2m(nm): function _nonfinite (line 735) | def _nonfinite(where, x, raiser=True, **kwds): # PYCHOK no cover function radians2m (line 745) | def radians2m(rad, earth=R_M, lat=0, **radius): function radiansPI (line 770) | def radiansPI(deg): function radiansPI2 (line 780) | def radiansPI2(deg): function radiansPI_2 (line 790) | def radiansPI_2(deg): function _rad2m (line 800) | def _rad2m(rad, earth, lat, **radius): function _sin0cos2 (line 807) | def _sin0cos2(q, r, sign): function SinCos2 (line 833) | def SinCos2(x, unit=Radians): function sincos2 (line 846) | def sincos2(rad): function sincos2_ (line 868) | def sincos2_(*rads): function sincos2d (line 883) | def sincos2d(deg, adeg=_0_0): function sincos2d_ (line 909) | def sincos2d_(*degs): function sincostan3 (line 924) | def sincostan3(rad): function _sincostan3 (line 936) | def _sincostan3(s, c): function sincostan3d (line 942) | def sincostan3d(deg): function SM2m (line 954) | def SM2m(sm): function tan_2 (line 966) | def tan_2(rad, **semi): # edge=1 function tan (line 989) | def tan(rad, **raiser_kwds): function tan_ (line 1007) | def tan_(*rads, **raiser_kwds): function tand (line 1023) | def tand(deg, **raiser_clamp_kwds): function tand_ (line 1042) | def tand_(*degs, **raiser_clamp_kwds): function tanPI_2_2 (line 1058) | def tanPI_2_2(rad): function _tanu (line 1069) | def _tanu(s, c, clamp=OVERFLOW, **unused): function toise2m (line 1084) | def toise2m(toises): function truncate (line 1099) | def truncate(x, ndigits=None): function unroll180 (line 1116) | def unroll180(lon1, lon2, wrap=True): function _unrollon (line 1138) | def _unrollon(p1, p2, wrap=False): # unroll180 == .karney._unroll2 function _unrollon3 (line 1151) | def _unrollon3(p1, p2, p3, wrap=False): function unrollPI (line 1163) | def unrollPI(rad1, rad2, wrap=True): class _Wrap (line 1185) | class _Wrap(object): method normal (line 1190) | def normal(self): method normal (line 1197) | def normal(self, setting): # PYCHOK no cover method latlonDMS2 (line 1208) | def latlonDMS2(self, lat, lon, **DMS2_kwds): # PYCHOK no cover method wraplatlon (line 1220) | def wraplatlon(self, lat, lon): method latlon3 (line 1225) | def latlon3(self, lon1, lat2, lon2, wrap): method _latlonop (line 1233) | def _latlonop(self, wrap): method wraphilam (line 1239) | def wraphilam(self, phi, lam): method philam3 (line 1244) | def philam3(self, lam1, phi2, lam2, wrap): method _philamop (line 1252) | def _philamop(self, wrap): method point (line 1258) | def point(self, ll, wrap=True): # in .points._fractional, -.PointsIte... function wrap90 (line 1291) | def wrap90(deg): function wrap180 (line 1301) | def wrap180(deg): function wrap360 (line 1317) | def wrap360(deg): # see .streprs._umod_360 function wrapPI (line 1327) | def wrapPI(rad): function wrapPI2 (line 1343) | def wrapPI2(rad): function wrapPI_2 (line 1353) | def wrapPI_2(rad): function wrap_normal (line 1369) | def wrap_normal(*normal): function _wrapu (line 1395) | def _wrapu(w, H, Q): function yard2m (line 1401) | def yard2m(yards, imperial=False): FILE: pygeodesy/utm.py class UTMError (line 76) | class UTMError(_ValueError): class _Kseries (line 82) | class _Kseries(object): method __init__ (line 89) | def __init__(self, AB, x, y): method xs (line 115) | def xs(self, x0): method ys (line 120) | def ys(self, y0): method ps (line 125) | def ps(self, p0): method qs (line 130) | def qs(self, q0): class Utm (line 136) | class Utm(UtmUpsBase): method __init__ (line 146) | def __init__(self, zone=31, hemisphere=_N_, easting=166022, # PYCHOK ... method __eq__ (line 201) | def __eq__(self, other): method __repr__ (line 209) | def __repr__(self): method __str__ (line 212) | def __str__(self): method _xcopy2 (line 215) | def _xcopy2(self, Xtm, **name): method band (line 226) | def band(self): method band (line 234) | def band(self, band): method _etm (line 245) | def _etm(self): method falsed2 (line 251) | def falsed2(self): method parse (line 261) | def parse(self, strUTM, **name): method parseUTM (line 277) | def parseUTM(self, strUTM): # PYCHOK no cover method pole (line 282) | def pole(self): method toEtm (line 287) | def toEtm(self): method toLatLon (line 294) | def toLatLon(self, LatLon=None, eps=EPS, unfalse=True, **LatLon_kwds): method _toLLEB (line 323) | def _toLLEB(self, unfalse=True, eps=EPS): # PYCHOK signature method toRepr (line 374) | def toRepr(self, prec=0, fmt=Fmt.SQUARE, sep=_COMMASPACE_, B=False, cs... method toStr (line 394) | def toStr(self, prec=0, sep=_SPACE_, B=False, cs=False): # PYCHOK exp... method toUps (line 418) | def toUps(self, pole=NN, eps=EPS, falsed=True, **unused): method toUtm (line 438) | def toUtm(self, zone, eps=EPS, falsed=True, **unused): method zone (line 461) | def zone(self): function _cmlon (line 467) | def _cmlon(zone): function _false2 (line 473) | def _false2(e, n, h): function _parseUTM5 (line 485) | def _parseUTM5(strUTM, datum, Xtm, falsed, Error=UTMError, **name): # i... function parseUTM5 (line 498) | def parseUTM5(strUTM, datum=_WGS84, Utm=Utm, falsed=True, **name): function toUtm8 (line 522) | def toUtm8(latlon, lon=None, datum=None, Utm=Utm, falsed=True, function _toBand (line 596) | def _toBand(lat, *unused, **strict_Error): # see ups._toBand function _toXtm8 (line 610) | def _toXtm8(Xtm, z, lat, x, y, B, d, g, k, f, # PYCHOK 13+ args function _to3zBlat (line 629) | def _to3zBlat(zone, band, Error=UTMError): # in .mgrs function _to4zBll (line 662) | def _to4zBll(lat, lon, cmoff=True, strict=True, Error=RangeError): function _to7zBlldfn (line 693) | def _to7zBlldfn(latlon, lon, datum, falsed, zone, strict, Error, **name_... function utmZoneBand5 (line 711) | def utmZoneBand5(lat, lon, cmoff=False, **name): FILE: pygeodesy/utmups.py class _UpsMinMax (line 53) | class _UpsMinMax(object): # XXX _NamedEnum or _NamedTuple class _UtmMinMax (line 61) | class _UtmMinMax(object): # XXX _NamedEnum or _NamedTuple class UTMUPSError (line 69) | class UTMUPSError(_ValueError): # XXX (UTMError, UPSError) function parseUTMUPS5 (line 76) | def parseUTMUPS5(strUTMUPS, datum=_WGS84, Utm=Utm, Ups=Ups, **name): function toUtmUps8 (line 108) | def toUtmUps8(latlon, lon=None, datum=None, falsed=True, Utm=Utm, Ups=Ups, function UtmUps (line 156) | def UtmUps(zone, hemipole, easting, northing, band=NN, datum=_WGS84, fal... function utmupsValidate (line 186) | def utmupsValidate(coord, falsed=False, MGRS=False, Error=UTMUPSError): function utmupsValidateOK (line 249) | def utmupsValidateOK(coord, falsed=False, ok=True): function utmupsZoneBand5 (line 268) | def utmupsZoneBand5(lat, lon, cmoff=False, **name): FILE: pygeodesy/utmupsBase.py class UtmUpsBase (line 67) | class UtmUpsBase(_NamedBase): method __init__ (line 85) | def __init__(self, easting, northing, band=NN, datum=None, falsed=True, method __repr__ (line 110) | def __repr__(self): method __str__ (line 113) | def __str__(self): method _band1 (line 116) | def _band1(self, band): method convergence (line 131) | def convergence(self): method datum (line 136) | def datum(self): method datum (line 142) | def datum(self, datum): method easting (line 151) | def easting(self): method eastingnorthing (line 157) | def eastingnorthing(self): method eastingnorthing2 (line 162) | def eastingnorthing2(self, falsed=True): method _epsg (line 181) | def _epsg(self): method falsed (line 187) | def falsed(self): method falsed2 (line 193) | def falsed2(self): # PYCHOK no cover method _footpoint (line 197) | def _footpoint(self, y, lat0, makris): method gamma (line 259) | def gamma(self): method hemisphere (line 266) | def hemisphere(self): method latFootPoint (line 273) | def latFootPoint(self, northing=None, lat0=0, makris=False): method _latlon5 (line 290) | def _latlon5(self, LatLon, **LatLon_kwds): method _latlon5args (line 303) | def _latlon5args(self, ll, g, k, _toBand, unfalse, *other): method _lowerleft (line 317) | def _lowerleft(self): # by .ellipsoidalBase._lowerleft method _mgrs (line 323) | def _mgrs(self): method _mgrs_lowerleft (line 329) | def _mgrs_lowerleft(self): method northing (line 336) | def northing(self): method phiFootPoint (line 341) | def phiFootPoint(self, northing=None, lat0=0, makris=False): method scale (line 351) | def scale(self): method scale0 (line 357) | def scale0(self): method to2en (line 363) | def to2en(self, falsed=True): # PYCHOK no cover method toEpsg (line 370) | def toEpsg(self): method _toLLEB (line 379) | def _toLLEB(self, **kwds): # PYCHOK no cover method toMgrs (line 383) | def toMgrs(self, center=False): method _toRepr (line 401) | def _toRepr(self, fmt, B, cs, prec, sep): # PYCHOK expected method _toStr (line 408) | def _toStr(self, hemipole, B, cs, prec, sep): function _hemi (line 422) | def _hemi(lat, N=0): # in .ups, .utm function _lowerleft (line 433) | def _lowerleft(utmups, center): # in .ellipsoidalBase._lowerleft function _parseUTMUPS5 (line 458) | def _parseUTMUPS5(strUTMUPS, UPS, Error=ParseError, band=NN, sep=_COMMA_): function _to4lldn (line 502) | def _to4lldn(latlon, lon, datum, name, wrap=False): function _toMgrs (line 520) | def _toMgrs(utmups): function _to3zBhp (line 526) | def _to3zBhp(zone, band, hemipole=NN, Error=_ValueError): # in .epsg, .... function _to3zll (line 571) | def _to3zll(lat, lon): # in .ups, .utm FILE: pygeodesy/vector2d.py class Circin6Tuple (line 52) | class Circin6Tuple(_NamedTuple): class Circum3Tuple (line 65) | class Circum3Tuple(_NamedTuple): # in .latlonBase class Circum4Tuple (line 77) | class Circum4Tuple(_NamedTuple): class Meeus2Tuple (line 87) | class Meeus2Tuple(_NamedTuple): class Radii11Tuple (line 98) | class Radii11Tuple(_NamedTuple): class Soddy4Tuple (line 111) | class Soddy4Tuple(_NamedTuple): class Triaxum5Tuple (line 124) | class Triaxum5Tuple(_NamedTuple): function circin6 (line 134) | def circin6(point1, point2, point3, eps=EPS4, useZ=True): function _circin6 (line 171) | def _circin6(point1, point2, point3, eps=EPS4, useZ=True, dLL3=False, **... function circum3 (line 196) | def circum3(point1, point2, point3, circum=True, eps=EPS4, useZ=True): function _circum3 (line 238) | def _circum3(p1, point2, point3, circum=True, eps=EPS4, useZ=True, dLL3=... function circum4 (line 251) | def circum4(points, useZ=True, **Vector_and_kwds): function circum4_ (line 302) | def circum4_(*points, **useZ_Vector_and_kwds): function _iscolinearWith (line 315) | def _iscolinearWith(p, point1, point2, eps=EPS, useZ=True): function meeus2 (line 324) | def meeus2(point1, point2, point3, circum=False, useZ=True): function _meeus2 (line 358) | def _meeus2(A, point2, point3, circum, useZ=True, **clas_and_kwds): # i... function _meeus4 (line 365) | def _meeus4(A, point2, point3, circum=False, useZ=True, clas=None, **cla... function nearestOn (line 399) | def nearestOn(point, point1, point2, **within_useZ_Vector_and_kwds): class _numpy (line 404) | class _numpy(object): # see also .formy._idllmn6, .geodesicw._wargs, .l... method __call__ (line 408) | def __call__(self, where, *args, **kwds): method array (line 423) | def array(self): method least_squares3 (line 428) | def least_squares3(self, A, b): method np (line 437) | def np(self): method null_space2 (line 442) | def null_space2(self, A, rcond=None): method pseudo_inverse (line 486) | def pseudo_inverse(self): method real_roots (line 491) | def real_roots(self, *coeffs): function radii11 (line 501) | def radii11(point1, point2, point3, useZ=True): function _radii11ABC4 (line 530) | def _radii11ABC4(point1, point2, point3, useZ=True): function soddy4 (line 576) | def soddy4(point1, point2, point3, eps=EPS4, useZ=True): function triaxum5 (line 615) | def triaxum5(points, useZ=True): function _tricenter3d2 (line 658) | def _tricenter3d2(p1, r1, p2, r2, p3, r3, eps=EPS4, useZ=True, dLL3=Fals... function trilaterate2d2 (line 685) | def trilaterate2d2(x1, y1, radius1, x2, y2, radius2, x3, y3, radius3, function _trilaterate2d2 (line 724) | def _trilaterate2d2(x1, y1, radius1, x2, y2, radius2, x3, y3, radius3, function _trilaterate3d2 (line 781) | def _trilaterate3d2(c1, r1, c2, r2, c3, r3, eps=EPS4, coin=False, # MCC... function _tri3near2far (line 857) | def _tri3near2far(r1, r2, h, coin): function _tri4near2far (line 863) | def _tri4near2far(c1, r1, c2, r2, coin): function _tri5perturbs (line 869) | def _tri5perturbs(eps, r): FILE: pygeodesy/vector3d.py class Vector3d (line 40) | class Vector3d(Vector3dBase): method bearing (line 51) | def bearing(self, useZ=True): method circin6 (line 64) | def circin6(self, point2, point3, eps=EPS4): method circum3 (line 97) | def circum3(self, point2, point3, circum=True, eps=EPS4): method circum4_ (line 129) | def circum4_(self, *points): method iscolinearWith (line 151) | def iscolinearWith(self, point1, point2, eps=EPS): method meeus2 (line 171) | def meeus2(self, point2, point3, circum=False): method nearestOn (line 196) | def nearestOn(self, point1, point2, within=True): method nearestOn6 (line 217) | def nearestOn6(self, points, closed=False, useZ=True): # eps=EPS method parse (line 242) | def parse(self, str3d, sep=_COMMA_, **name): method radii11 (line 255) | def radii11(self, point2, point3): method soddy4 (line 280) | def soddy4(self, point2, point3, eps=EPS4): method toCartesian (line 307) | def toCartesian(self, Cartesian, **Cartesian_kwds): method trilaterate2d2 (line 318) | def trilaterate2d2(self, radius, center2, radius2, center3, radius3, e... method trilaterate3d2 (line 361) | def trilaterate3d2(self, radius, center2, radius2, center3, radius3, e... function _intersect3d3 (line 413) | def _intersect3d3(start1, end1, start2, end2, eps=EPS, useZ=False): # M... function intersection3d3 (line 495) | def intersection3d3(start1, end1, start2, end2, eps=EPS, useZ=True, function intersections2 (line 537) | def intersections2(center1, radius1, center2, radius2, sphere=True, **Ve... function _intersects2 (line 582) | def _intersects2(center1, r1, center2, r2, sphere=True, too_d=None, # i... function iscolinearWith (line 642) | def iscolinearWith(point, point1, point2, eps=EPS, useZ=True): function nearestOn (line 662) | def nearestOn(point, point1, point2, within=True, useZ=True, Vector=None... function _nearestOn2 (line 705) | def _nearestOn2(p0, p1, p2, within=True, eps=EPS): function nearestOn6 (line 726) | def nearestOn6(point, points, closed=False, useZ=True, **Vector_and_kwds... function _nVc (line 780) | def _nVc(v, clas=None, Vector=None, **name_Vector_kwds): # in .vector2d function _otherV3d (line 790) | def _otherV3d(useZ=True, NN_OK=True, i=None, **name_vector): function parse3d (line 803) | def parse3d(str3d, sep=_COMMA_, Vector=Vector3d, **Vector_kwds): function sumOf (line 828) | def sumOf(vectors, Vector=Vector3d, **Vector_kwds): function trilaterate3d2 (line 850) | def trilaterate3d2(center1, radius1, center2, radius2, center3, radius3, function _xyzhdlln4 (line 904) | def _xyzhdlln4(xyz, height, datum, ll=None, **name): # in .cartesianBas... FILE: pygeodesy/vector3dBase.py class Vector3dBase (line 35) | class Vector3dBase(_NamedBase): # sync __methods__ with .fsums.Fsum method __init__ (line 45) | def __init__(self, x_xyz, y=INT0, z=INT0, ll=None, **name): method __abs__ (line 74) | def __abs__(self): method __add__ (line 81) | def __add__(self, other): method __bool__ (line 90) | def __bool__(self): # PYCHOK PyChecker method __ceil__ (line 97) | def __ceil__(self): # PYCHOK no cover method __cmp__ (line 104) | def __cmp__(self, other): # Python 2- method __divmod__ (line 115) | def __divmod__(self, scalar): # PYCHOK no cover method __eq__ (line 130) | def __eq__(self, other): method __float__ (line 141) | def __float__(self): # PYCHOK no cover method __floor__ (line 145) | def __floor__(self): # PYCHOK no cover method __floordiv__ (line 152) | def __floordiv__(self, scalar): # PYCHOK no cover method __ge__ (line 163) | def __ge__(self, other): method __gt__ (line 179) | def __gt__(self, other): method __hash__ (line 190) | def __hash__(self): # PYCHOK no cover method __iadd__ (line 195) | def __iadd__(self, other): method __ifloordiv__ (line 204) | def __ifloordiv__(self, scalar): # PYCHOK no cover method __imatmul__ (line 213) | def __imatmul__(self, other): # PYCHOK Python 3.5+ method __imod__ (line 224) | def __imod__(self, other): # PYCHOK no cover method __imul__ (line 228) | def __imul__(self, scalar): method __int__ (line 237) | def __int__(self): # PYCHOK no cover method __ipow__ (line 241) | def __ipow__(self, scalar, *mod): # PYCHOK no cover method __isub__ (line 252) | def __isub__(self, other): method __itruediv__ (line 266) | def __itruediv__(self, scalar): method __le__ (line 275) | def __le__(self, other): # Python 3+ method __lt__ (line 291) | def __lt__(self, other): # Python 3+ method __matmul__ (line 302) | def __matmul__(self, other): # PYCHOK Python 3.5+ method __mod__ (line 313) | def __mod__(self, modulus): # PYCHOK no cover method __mul__ (line 327) | def __mul__(self, scalar): method __ne__ (line 336) | def __ne__(self, other): method __neg__ (line 347) | def __neg__(self): method __pos__ (line 354) | def __pos__(self): # PYCHOK no cover method __pow__ (line 361) | def __pow__(self, scalar, *mod): # PYCHOK no cover method __radd__ (line 372) | def __radd__(self, other): # PYCHOK no cover method __rdivmod__ (line 383) | def __rdivmod__(self, other): method __rfloordiv__ (line 392) | def __rfloordiv__(self, other): method __rmatmul__ (line 396) | def __rmatmul__(self, other): # PYCHOK Python 3.5+ method __rmod__ (line 407) | def __rmod__(self, other): method __round__ (line 413) | def __round__(self, *ndigits): # PYCHOK no cover method __rpow__ (line 426) | def __rpow__(self, other, *mod): # PYCHOK no cover method __rsub__ (line 430) | def __rsub__(self, other): # PYCHOK no cover method __rtruediv__ (line 441) | def __rtruediv__(self, other): method __sub__ (line 450) | def __sub__(self, other): method __truediv__ (line 461) | def __truediv__(self, scalar): method __trunc__ (line 472) | def __trunc__(self): # PYCHOK no cover method angleTo (line 487) | def angleTo(self, other, vSign=None, wrap=False): method apply (line 513) | def apply(self, fun2, other_x, *y_z, **fun2_kwds): method bools (line 541) | def bools(self): method cross (line 546) | def cross(self, other, raiser=None, eps0=EPS): # raiser=NN method crosserrors (line 578) | def crosserrors(self): method crosserrors (line 584) | def crosserrors(self, raiser): method dividedBy (line 589) | def dividedBy(self, scalar): method dividedBy_ (line 606) | def dividedBy_(self, scalar_x, *y_z): method dot (line 623) | def dot(self, other): method equals (line 636) | def equals(self, other, units=False): # PYCHOK no cover method euclid (line 642) | def euclid(self): method equirectangular (line 650) | def equirectangular(self, other): method fabs (line 664) | def fabs(self): method floats (line 669) | def floats(self): method floorDividedBy (line 674) | def floorDividedBy(self, scalar): method floorDividedBy_ (line 694) | def floorDividedBy_(self, scalar_x, *y_z): method _fromll (line 712) | def _fromll(self): method _fromll (line 718) | def _fromll(self, ll): method homogeneous (line 724) | def homogeneous(self): method intermediateTo (line 738) | def intermediateTo(self, other, fraction, **unused): # height=None, w... method ints (line 759) | def ints(self): method isconjugateTo (line 764) | def isconjugateTo(self, other, minum=1, eps=EPS): method isequalTo (line 790) | def isequalTo(self, other, units=False, eps=EPS): method length (line 813) | def length(self): # __dict__ value overwritten by Property_RO C{_united} method length2 (line 821) | def length2(self): # __dict__ value overwritten by Property_RO C{_uni... method _mapped (line 828) | def _mapped(self, func): method minus (line 833) | def minus(self, other): method _minus (line 844) | def _minus(self, x, y, z): method minus_ (line 849) | def minus_(self, other_x, *y_z): method negate (line 865) | def negate(self): method _N_vector (line 873) | def _N_vector(self): method _other_cmp (line 879) | def _other_cmp(self, other): method others (line 884) | def others(self, *other, **name_other_up): method plus (line 900) | def plus(self, other): method _plus (line 913) | def _plus(self, x, y, z): method plus_ (line 918) | def plus_(self, other_x, *y_z): method pow (line 934) | def pow(self, scalar, *mod): method rotate (line 950) | def rotate(self, axis, theta, fma=False): method rotateAround (line 988) | def rotateAround(self, axis, theta): method _roty (line 992) | def _roty(self, *pos, **name): method times (line 1002) | def times(self, factor): method _times (line 1013) | def _times(self, s): method times_ (line 1018) | def times_(self, other_x, *y_z): method to3xyz (line 1052) | def to3xyz(self): # PYCHOK no cover method toStr (line 1057) | def toStr(self, prec=5, fmt=Fmt.PAREN, sep=_COMMASPACE_): # PYCHOK ex... method unit (line 1069) | def unit(self, ll=None): method _united (line 1082) | def _united(self): # __dict__ value overwritten below method x (line 1097) | def x(self): method x (line 1103) | def x(self, x): method xyz (line 1112) | def xyz(self): method xyz (line 1118) | def xyz(self, xyz): method _xyz (line 1125) | def _xyz(self, x_xyz, *y_z): method xyz3 (line 1135) | def xyz3(self): method x2y2z2 (line 1141) | def x2y2z2(self): method x2y2z23 (line 1147) | def x2y2z23(self): method y (line 1153) | def y(self): method y (line 1159) | def y(self, y): method z (line 1168) | def z(self): method z (line 1174) | def z(self, z): function _xyz3 (line 1183) | def _xyz3(where, x_xyz, *y_z): # in .cartesianBase._rtp3 FILE: pygeodesy/webmercator.py class EasNorRadius3Tuple (line 48) | class EasNorRadius3Tuple(_NamedTuple): class WebMercatorError (line 55) | class WebMercatorError(_ValueError): class Wm (line 61) | class Wm(_NamedBase): method __init__ (line 70) | def __init__(self, x, y, earth=R_MA, **name_radius): method datum (line 96) | def datum(self): method ellipsoid (line 102) | def ellipsoid(self): method latlon (line 108) | def latlon(self): method latlon2 (line 113) | def latlon2(self, datum=None): method parse (line 145) | def parse(self, strWM, **name): method parseWM (line 159) | def parseWM(self, strWM, name=NN): # PYCHOK no cover method philam (line 164) | def philam(self): method radius (line 170) | def radius(self): method to2ll (line 176) | def to2ll(self, datum=None): # PYCHOK no cover method toLatLon (line 183) | def toLatLon(self, LatLon=None, datum=None, **LatLon_kwds): method toRepr (line 205) | def toRepr(self, prec=3, fmt=Fmt.SQUARE, sep=_COMMASPACE_, radius=Fals... method toStr (line 224) | def toStr(self, prec=3, fmt=Fmt.F, sep=_SPACE_, radius=False, **unused... method x (line 250) | def x(self): method y (line 256) | def y(self): function _datum (line 265) | def _datum(earth, name=_datum_): function parseWM (line 276) | def parseWM(strWM, radius=R_MA, Wm=Wm, **name): function toWm (line 308) | def toWm(latlon, lon=None, earth=R_MA, Wm=Wm, **name_Wm_kwds_radius): FILE: pygeodesy/wgrs.py function _divmod3 (line 61) | def _divmod3(x, _Orig_60B): function _2fll (line 70) | def _2fll(lat, lon): function _2geostr2 (line 78) | def _2geostr2(georef): function _2Precision (line 93) | def _2Precision(precision): class WGRSError (line 99) | class WGRSError(_ValueError): class Georef (line 105) | class Georef(Str): method __new__ (line 109) | def __new__(cls, lat_gll, lon=None, height=None, precision=3, name=NN): method decoded3 (line 159) | def decoded3(self): method decoded5 (line 166) | def decoded5(self): method _decoded5 (line 173) | def _decoded5(self): method height (line 179) | def height(self): method latlon (line 185) | def latlon(self): method latlonheight (line 192) | def latlonheight(self): method precision (line 199) | def precision(self): method radius (line 206) | def radius(self): method toLatLon (line 211) | def toLatLon(self, LatLon=None, height=None, **name_LatLon_kwds): function decode3 (line 232) | def decode3(georef, center=True): function decode5 (line 285) | def decode5(georef, center=True): function encode (line 319) | def encode(lat, lon, precision=3, height=None, radius=None): # MCCABE 14 function _encode3 (line 355) | def _encode3(lat, lon, precision, h=None): function precision (line 382) | def precision(res): function resolution (line 401) | def resolution(prec): FILE: setup.py function _c (line 35) | def _c(*names): function _long_description (line 39) | def _long_description(): function _version (line 47) | def _version(): FILE: test/bases.py class RandomLatLon (line 102) | class RandomLatLon(object): method __init__ (line 107) | def __init__(self, LatLon, lat_=170, lon_=350, ndigits=None): # +/- r... method __call__ (line 114) | def __call__(self, **LatLon_kwds): method _random_round (line 119) | def _random_round(self, limit): class TestsBase (line 127) | class TestsBase(object): method __init__ (line 148) | def __init__(self, testfile, version, module=None, verbose=True, method errors (line 164) | def errors(self): method exit (line 170) | def exit(self, errors=0): method iterNumpy2over (line 175) | def iterNumpy2over(self, n=None): method name (line 187) | def name(self): method printf (line 190) | def printf(self, fmt, *args, **kwds): # nl=0, nt=0 method pygeodesy_classes (line 195) | def pygeodesy_classes(self, Base=None, deprecated=False): method pygeodesy_classes_ (line 206) | def pygeodesy_classes_(self, Base, *Classes): method pygeodesy_modules (line 213) | def pygeodesy_modules(self, deprecated=False): method pygeodesy_names2 (line 232) | def pygeodesy_names2(self, deprecated=False): method results (line 246) | def results(self, passed='passed', nl=1): method skip (line 278) | def skip(self, text=NN, n=1): method subtitle (line 286) | def subtitle(self, module, testing='ing', **kwds): method test (line 292) | def test(self, name, value, expect, error=0, **kwds): method test_tol (line 330) | def test_tol(self, name, value, expect, tol=1e-12, **kwds): method test__ (line 340) | def test__(self, fmt, *args, **kwds): method testCopy (line 346) | def testCopy(self, inst, *attrs, **kwds): # Clas=None method testiter (line 361) | def testiter(self): method title (line 369) | def title(self, test, version, module=None): method verbose (line 381) | def verbose(self): method verbose (line 387) | def verbose(self, v): method versions (line 393) | def versions(self): class TestError (line 399) | class TestError(RuntimeError): # ValueError's are often caught method __init__ (line 402) | def __init__(self, fmt, *args): function _env_c2 (line 406) | def _env_c2(c, dev_null='>/dev/null', NUL_='>NUL:'): # .testFrozen, .te... function _fLate (line 423) | def _fLate(f): function _get_kwds (line 429) | def _get_kwds(fmt='%s', prec=0, known=False, **kwds): function prefix2 (line 439) | def prefix2(prev): # in .run function tilde (line 448) | def tilde(path): function type2str (line 454) | def type2str(obj, attr, **renamed): function versions (line 489) | def versions(): function _X_OK (line 531) | def _X_OK(_Xables, which): FILE: test/run.py function run2 (line 31) | def run2(test, *unused): function run2 (line 95) | def run2(test, *opts): # PYCHOK expected class Lock (line 112) | class Lock(object): method __enter__ (line 113) | def __enter__(self): method __exit__ (line 116) | def __exit__(self, *unused): # PYCHOK 4 args class ThreadPool (line 120) | class ThreadPool(object): method __init__ (line 124) | def __init__(self, size=9): method onedown (line 129) | def onedown(self): method shutdown (line 133) | def shutdown(self, prefix=NN): method submit (line 145) | def submit(self, call, *args): function _exit (line 182) | def _exit(last, text, exit): function _prefix2 (line 194) | def _prefix2(prev): function _run (line 200) | def _run(prefix, test, *opts): # MCCABE 13 function _testlines (line 247) | def _testlines(r, skipped): function _write (line 258) | def _write(text): FILE: test/testAlbers.py class Tests (line 21) | class Tests(TestsBase): method testAlbers2 (line 23) | def testAlbers2(self): method testLats (line 103) | def testLats(self): FILE: test/testAngles.py class Tests (line 17) | class Tests(TestsBase): method testAngles (line 19) | def testAngles(self): # MCCABE 26 FILE: test/testAuxilats.py class Tests (line 16) | class Tests(TestsBase): method testAngles (line 18) | def testAngles(self, deltas): method testCoeffs (line 65) | def testCoeffs(self): method testCXoeffs (line 76) | def testCXoeffs(self): method testDST (line 94) | def testDST(self, enums): FILE: test/testAzimuthal.py class Tests (line 20) | class Tests(TestsBase): method testAzimuthal (line 22) | def testAzimuthal(self, Azimuthal, *xs): method testDiscrepancies (line 61) | def testDiscrepancies(self): method testSnyder (line 125) | def testSnyder(self, lat, lon, As, *xys): FILE: test/testBasics.py class C (line 17) | class C(object): method r_o (line 22) | def r_o(self): class Tests (line 26) | class Tests(TestsBase): method testBasics (line 28) | def testBasics(self): FILE: test/testBooleans.py class Tests (line 14) | class Tests(TestsBase): method testBooleans (line 16) | def testBooleans(self, module): # MCCABE 15 FILE: test/testCartesian.py class Tests (line 21) | class Tests(TestsBase): method testCartesian (line 23) | def testCartesian(self, module, Sph=False, Nv=False, X=False): # MCCA... method testReturnType (line 203) | def testReturnType(self, inst, clas, name): FILE: test/testClasses.py class Tests (line 27) | class Tests(TestsBase): method _subtitle (line 29) | def _subtitle(self, classname, testing, unused): method testAttrs (line 33) | def testAttrs(self, classname, modules, *args, **kwds): method testMro (line 49) | def testMro(self, classname, modules): method testCartesianAttrs (line 57) | def testCartesianAttrs(self, *modules): method testCopyAttr (line 61) | def testCopyAttr(self, package): method testLatLonAttrs (line 70) | def testLatLonAttrs(self, *modules): method testVectorAttrs (line 74) | def testVectorAttrs(self, *modules): FILE: test/testClipy.py function _lles3 (line 16) | def _lles3(*lles): function _llsTrue3 (line 23) | def _llsTrue3(lls): function _4Ts (line 30) | def _4Ts(*cs): class Tests (line 37) | class Tests(TestsBase): method testClipy (line 39) | def testClipy(self, module): # MCCABE 15 method testClipSH_ (line 279) | def testClipSH_(self, text, sh, lls): FILE: test/testConstants.py class Tests (line 17) | class Tests(TestsBase): method testConstants (line 19) | def testConstants(self): FILE: test/testCss.py class Tests (line 15) | class Tests(TestsBase): method testCss (line 17) | def testCss(self, LatLons): FILE: test/testDatums.py class Tests (line 16) | class Tests(TestsBase): method testDatum (line 18) | def testDatum(self): method testDatums (line 46) | def testDatums(self): FILE: test/testDeprecated.py class Tests (line 24) | class Tests(TestsBase): method testDeprecated (line 26) | def testDeprecated(self, LatLon): method testDEPRECATED (line 96) | def testDEPRECATED(self, *known): FILE: test/testDms.py class Tests (line 18) | class Tests(TestsBase): method testDms (line 20) | def testDms(self): # MCCABE 14 FILE: test/testEcef.py function _known (line 18) | def _known(t, lat, h, d_h=10.0): class Tests (line 23) | class Tests(TestsBase): method testEcef (line 25) | def testEcef(self, Ecef): method testEcefMatrix (line 166) | def testEcefMatrix(self): method testLatLonEcef (line 196) | def testLatLonEcef(self, module, Ecef): FILE: test/testElevations.py class Tests (line 14) | class Tests(TestsBase): method testApprox (line 16) | def testApprox(self, name, m, e, x): method testElevations (line 24) | def testElevations(self, LatLon, datum, timeout): method testError (line 60) | def testError(self, name, m, x, error): FILE: test/testEllipses.py class Tests (line 14) | class Tests(TestsBase): method testEllipse (line 16) | def testEllipse(self): FILE: test/testEllipsoidal.py class Tests (line 22) | class Tests(_TestsLL, _TestsV): method testEllipsoidal (line 24) | def testEllipsoidal(self, module, Cartesian, Nvector, GS=False, V=Fals... method testKarney (line 191) | def testKarney(self, module, datum, X=False, GS=False): method testKarney_s (line 230) | def testKarney_s(self, module, X=False): method testVincenty (line 272) | def testVincenty(self, module, datum, X=False, GS=False): method testKarneyVincenty (line 316) | def testKarneyVincenty(self, module, LatLon, d, **unused): # GS=False... method testKarneyVincentyError (line 464) | def testKarneyVincentyError(self, module, LatLon, d, K=False, X=False,... method testNOAA (line 571) | def testNOAA(self, module): method testIntersection3 (line 604) | def testIntersection3(self, m, GS=False, K=False, X=False, V=False): method testIntersections2 (line 649) | def testIntersections2(self, m, Eq, GS=False, K=False, X=False, V=Fals... FILE: test/testEllipsoidalGeodTest.py class Tests (line 23) | class Tests(TestsBase): method testGeodTest (line 25) | def testGeodTest(self, test, line, precV, epsV, precK, epsK, precX, ep... FILE: test/testEllipsoids.py class Tests (line 18) | class Tests(TestsBase): method testEllipsoids (line 20) | def testEllipsoids(self): # MCCABE 14 FILE: test/testElliptic.py class Tests (line 15) | class Tests(TestsBase): method testElliptic (line 17) | def testElliptic(self): # MCCABE 13 FILE: test/testEpsg.py class Tests (line 14) | class Tests(TestsBase): method testEpsg (line 16) | def testEpsg(self, decode, encode): method testEpsgTMcoord (line 36) | def testEpsgTMcoord(self, n, lat, lon): FILE: test/testErrors.py class Tests (line 18) | class Tests(TestsBase): method testError (line 20) | def testError(self, Error): method testErrors (line 32) | def testErrors(self, InvalidError, IsnotError): method testKwds (line 74) | def testKwds(self, xkwds): function _xkwds_pop (line 102) | def _xkwds_pop(kwds, **name_default): FILE: test/testEtm.py class Tests (line 15) | class Tests(TestsBase): method testEtm (line 17) | def testEtm(self, LatLon): method testExactTM (line 39) | def testExactTM(self, extendp): FILE: test/testEtmTMcoords.py function testEtmTMcoords (line 15) | def testEtmTMcoords(name): FILE: test/testExactTMcoords.py class _ExactTM (line 19) | class _ExactTM(object): method __init__ (line 25) | def __init__(self, lat, lon, **unused): method toLatLon (line 28) | def toLatLon(self, **unused): function testExactTMcoords (line 33) | def testExactTMcoords(name): FILE: test/testFmath.py class Tests (line 24) | class Tests(TestsBase): method testFmath (line 26) | def testFmath(self): # MCCABE 14 FILE: test/testFormy.py class Tests (line 25) | class Tests(TestsBase): method testDistance (line 27) | def testDistance(self, t, f, lat1, lon1, lat2, lon2, x, m, **kwds): method testDistances (line 33) | def testDistances(self, t, lat1, lon1, lat2, lon2, x=0): method testDistances2 (line 59) | def testDistances2(self, t, lat1, lon1, lat2, lon2, x=0, **datum): method testFormy (line 77) | def testFormy(self): # MCCABE 13 method testIntersections2 (line 219) | def testIntersections2(self, datum): FILE: test/testFrechet.py class Tests (line 22) | class Tests(TestsBase): method test2 (line 24) | def test2(self, Frechet, x, y, **kwds): function _distance (line 65) | def _distance(p1, p2): class FrechetDegrees_ (line 69) | class FrechetDegrees_(FrechetDegrees): method distance (line 71) | def distance(self, p1, p2): class FrechetRadians_ (line 74) | class FrechetRadians_(FrechetRadians): method distance (line 76) | def distance(self, p1, p2): FILE: test/testFrozen.py class Tests (line 12) | class Tests(TestsBase): method testFrozen (line 14) | def testFrozen(self): FILE: test/testFstats.py class Tests (line 15) | class Tests(TestsBase): method testFstats (line 17) | def testFstats(self): method test_x (line 138) | def test_x(self, name, x): FILE: test/testFsums.py class Tests (line 20) | class Tests(TestsBase): method testFsums (line 22) | def testFsums(self, Fsum): # MCCABE 26 FILE: test/testGars.py class Tests (line 14) | class Tests(TestsBase): method testCodec3 (line 16) | def testCodec3(self, g, x, prec=4): method testGars (line 22) | def testGars(self, LL): FILE: test/testGeodesici.py class _LL (line 15) | class _LL(LatLon_): method __abs__ (line 17) | def __abs__(self): method __neg__ (line 20) | def __neg__(self): method __sub__ (line 23) | def __sub__(self, other): function _re (line 28) | def _re(v, x): # rel error class Tests (line 37) | class Tests(TestsBase): method test_ (line 43) | def test_(self, name, v, **nl): method testEnumerate (line 63) | def testEnumerate(self, name, y): method testItems (line 71) | def testItems(self, name, t): method testIntersect (line 77) | def testIntersect(self, Intersect, G, **_C): FILE: test/testGeodesicx.py function _t3 (line 19) | def _t3(n_p_a): class Tests (line 23) | class Tests(TestsBase): method testDiffs (line 25) | def testDiffs(self, name, r, rx, nl, e=1e-13): method testDirect (line 33) | def testDirect(self, geodesicx, E, debug=False): method testInverse (line 108) | def testInverse(self, geodesicx, E, debug=False): method testPlumbTo (line 191) | def testPlumbTo(self, geodesicx, E, debug=False): method testPolygon (line 230) | def testPolygon(self, module, g, nC4=NN, K=False): FILE: test/testGeohash.py class Tests (line 14) | class Tests(TestsBase): method testGeohash (line 16) | def testGeohash(self, LL): FILE: test/testGeoids.py class Tests (line 251) | class Tests(TestsBase): method dat5llhs3 (line 260) | def dat5llhs3(self, grid, hIndex=4): method testGeoid (line 277) | def testGeoid(self, G, grid, llh3, eps=None, kind=None, **crop): # MC... FILE: test/testGreatCircle.py class Tests (line 43) | class Tests(TestsBase): method testGreatCircle (line 45) | def testGreatCircle(self, module): # spherical only FILE: test/testHausdorff.py class HausdorffDegrees_ (line 21) | class HausdorffDegrees_(HausdorffDegrees): method distance (line 23) | def distance(self, p1, p2): class HausdorffRadians_ (line 30) | class HausdorffRadians_(HausdorffRadians): method distance (line 32) | def distance(self, p1, p2): function _tstr (line 39) | def _tstr(t): class Tests (line 55) | class Tests(TestsBase): method test4 (line 57) | def test4(self, Hausdorff, *tests, **kwds): method test4_ (line 72) | def test4_(self, H_, *tests): function _4 (line 88) | def _4(t5directed, t5symmetric): FILE: test/testHeights.py function _fstr (line 29) | def _fstr(floats): function _kwdstr (line 35) | def _kwdstr(kwds): class Tests (line 39) | class Tests(TestsBase): method testHeight (line 41) | def testHeight(self, H, kts, lli, expected, lats, lons, known=False, *... method testHeightError (line 63) | def testHeightError(self, interpolator, *attrs): method testIDW (line 75) | def testIDW(self, IDW, kts, lli, expected, **kwds): method testHeights (line 112) | def testHeights(self): FILE: test/testInterns.py class Tests (line 35) | class Tests(TestsBase): method testInterns (line 37) | def testInterns(self): FILE: test/testIters.py class Tests (line 14) | class Tests(TestsBase): method testIters (line 16) | def testIters(self): FILE: test/testKarney.py function _signOf (line 42) | def _signOf(x): class Tests (line 46) | class Tests(TestsBase): method testDelta (line 48) | def testDelta(self, n, x, v, e=1e-10, prec=12): method testDirect (line 53) | def testDirect(self, g, module): method testInverse (line 70) | def testInverse(self, g, module): method testInverseLine (line 105) | def testInverseLine(self, g, module): method testGeodCalc (line 118) | def testGeodCalc(self, module, X=False): method testMask (line 143) | def testMask(self, G, module): method testMath (line 160) | def testMath(self): method testSum3 (line 210) | def testSum3(self, txt, x, *xs): FILE: test/testKarneySigns.py function _sign (line 20) | def _sign(x): class Tests (line 24) | class Tests(TestsBase): method _T2 (line 27) | def _T2(self, which, *tuples): method test_eqv (line 34) | def test_eqv(self, n, y, x, **kwds): method test_AngDiff (line 39) | def test_AngDiff(self): method test_AngNormalize (line 59) | def test_AngNormalize(self): method test_AngRound (line 76) | def test_AngRound(self): method test_antipodal (line 123) | def test_antipodal(self): method test_antipodal_prolate (line 134) | def test_antipodal_prolate(self): method test_azimuth_0_180 (line 144) | def test_azimuth_0_180(self): method test_equatorial_coincident (line 156) | def test_equatorial_coincident(self): method test_equatorial_NS (line 165) | def test_equatorial_NS(self): method test_atan2d (line 174) | def test_atan2d(self): method test_sincosd (line 208) | def test_sincosd(self): method test_sum2 (line 246) | def test_sum2(self): FILE: test/testKtm.py class Tests (line 14) | class Tests(TestsBase): method testKtm (line 16) | def testKtm(self, xTM, known, fw=NN, rv=NN): FILE: test/testLatLon.py class Tests (line 21) | class Tests(TestsBase): method testLatLon (line 23) | def testLatLon(self, module, Sph=False, Nv=False, X=False, GS=False): ... method testReturnType (line 633) | def testReturnType(self, inst, clas, name): FILE: test/testLatLonBase.py class Tests (line 14) | class Tests(TestsBase): method testBases (line 16) | def testBases(self, module, LatLon, Base=False, Sph=False): FILE: test/testLazily.py class Tests (line 13) | class Tests(TestsBase): method testLazily (line 15) | def testLazily(self): FILE: test/testLcc.py class Tests (line 14) | class Tests(TestsBase): method testConic (line 16) | def testConic(self, module, n=''): method testLcc (line 38) | def testLcc(self, module): FILE: test/testLtp.py function _absdiff (line 19) | def _absdiff(a, *b): class Tests (line 24) | class Tests(TestsBase): method testLtp (line 26) | def testLtp(self, Ltp, **kwds): method testChLV (line 150) | def testChLV(self, ChLV_): FILE: test/testLtpTuples.py function _truncate (line 16) | def _truncate(txt, n=392): class Tests (line 26) | class Tests(TestsBase): method testLoc (line 28) | def testLoc(self, Loc, *args, **kwds): class Xyz (line 86) | class Xyz(XyzLocal): # shorten name FILE: test/testMgrs.py class Tests (line 14) | class Tests(TestsBase): method testMgrs (line 16) | def testMgrs(self, LatLon): FILE: test/testModules.py class Tests (line 14) | class Tests(TestsBase): method testModule (line 16) | def testModule(self, m, name=''): function _parent (line 30) | def _parent(obj, dflt): FILE: test/testNamed.py function _mod_line (line 24) | def _mod_line(m, py): class Tests (line 31) | class Tests(TestsBase): method testBases (line 33) | def testBases(self): method testNamed (line 55) | def testNamed(self, N, *args, **kwds): method testNamedDicts (line 92) | def testNamedDicts(self): method testNamedTuples (line 99) | def testNamedTuples(self): method testNamed_classes (line 107) | def testNamed_classes(self, _Nclass, _attr_, _Ndict, *_Nbases): method testNamed__doc__ (line 137) | def testNamed__doc__(self, m, py): method testNamed_Link (line 151) | def testNamed_Link(self, _N, i, m, py, _Ndict, b=30): method testNamed_xtend (line 163) | def testNamed_xtend(self, namedTuples): method testUnregister (line 196) | def testUnregister(self): FILE: test/testNamedTuples.py class Tests (line 30) | class Tests(TestsBase): method testNamedTuple (line 32) | def testNamedTuple(self, T, *args): method testNamedTuples (line 69) | def testNamedTuples(self): method testValidated (line 79) | def testValidated(self, T, x): FILE: test/testNavlabExamples.py class Examples (line 23) | class Examples(TestsBase): # overload test() method test (line 24) | def test(self, ex, name, *args, **kwds): function destination (line 28) | def destination(m, x, **nl): FILE: test/testOsgr.py class Tests (line 15) | class Tests(TestsBase): method testOSgr (line 17) | def testOSgr(self, module): FILE: test/testPoints.py class Tests (line 26) | class Tests(TestsBase): method test2 (line 28) | def test2(self, pts, npt, psxy=False): method test3 (line 98) | def test3(self, LatLon, oK=True, X=False): method testArea (line 229) | def testArea(self, module, area): FILE: test/testProps.py class Tests (line 14) | class Tests(TestsBase): method testProps (line 16) | def testProps(self, Base, *args): # MCCABE 26 FILE: test/testResections.py class Tests (line 18) | class Tests(TestsBase): method testResections (line 20) | def testResections(self, C_, V3d): method testSnellius (line 96) | def testSnellius(self): method testTri (line 123) | def testTri(self): # for coverage method testWildberger (line 139) | def testWildberger(self): class Cartesian_ (line 162) | class Cartesian_(CartesianBase): FILE: test/testRhumb_aux_.py class Tests (line 22) | class Tests(TestsBase): method testDiffs (line 24) | def testDiffs(self, name, r, rx, nl, e=1e-13, known=False): method testDirect (line 33) | def testDirect(self, E, debug=False): method testInverse (line 125) | def testInverse(self, E, debug=False): method testRhumbLine (line 215) | def testRhumbLine(self, E): FILE: test/testRhumb_ekx.py class Tests (line 22) | class Tests(TestsBase): method testDiffs (line 24) | def testDiffs(self, name, r, rx, nl, e=1e-13): method testDirect (line 35) | def testDirect(self, E, debug=False): method testInverse (line 127) | def testInverse(self, E, debug=False): method testRhumbLine (line 217) | def testRhumbLine(self, E): FILE: test/testRoutes.py function _2LL (line 17078) | def _2LL(pts, LL): class Tests (line 17084) | class Tests(TestsBase): method test7 (line 17086) | def test7(self, f, xs, fmt='%.3f', skip=False, LL=None, known=False, *... method testAreas (line 17107) | def testAreas(self): method testClockwise (line 17136) | def testClockwise(self): method testPerimeters (line 17142) | def testPerimeters(self): method testGeodesic (line 17166) | def testGeodesic(self): FILE: test/testSimplify.py class Tests (line 23) | class Tests(TestsBase): method test2 (line 25) | def test2(self, function, points, ms, typ=None, **kwds): function simplifyRDPfw (line 53) | def simplifyRDPfw(points, epsilon, radius=R_M, adjust=False, shortest=Fa... function simplifyRDPgr (line 130) | def simplifyRDPgr(source, kink, radius=R_M, adjust=True, shortest=True, ... function _ms (line 223) | def _ms(ms): # reduce the number of tests FILE: test/testSpherical.py class Tests (line 39) | class Tests(_TestsLL, _TestsV): method testSpherical (line 41) | def testSpherical(self, module, Sph=True, Nv=False): # MCCABE 13 FILE: test/testStreprs.py class Tests (line 15) | class Tests(TestsBase): method testFmt (line 17) | def testFmt(self, fmt, x): method testStreprs (line 23) | def testStreprs(self): FILE: test/testTMcoords.py class Tests (line 298) | class Tests(TestsBase): method testTMcoord (line 303) | def testTMcoord(self, coord, line, toEtmUtmUps8, fmt='%.6f', eps1=25.0... function testTMcoords (line 346) | def testTMcoords(etmutmups, toEtmUtmUps8, name='', **EtmUtmUps): FILE: test/testTrf.py class Tests (line 19) | class Tests(TestsBase): method testTrf (line 21) | def testTrf(self, ellipsoidal_): # MCCABE 17 method testEpoch (line 353) | def testEpoch(self): FILE: test/testTriaxials.py function _r (line 21) | def _r(s): class Tests (line 33) | class Tests(TestsBase): method testAreas (line 35) | def testAreas(self): method testHartzell (line 55) | def testHartzell(self, module, LatLon): method testConformal (line 108) | def testConformal(self, module): method testConformalSphere (line 166) | def testConformalSphere(self, module): method testConformal3 (line 224) | def testConformal3(self, module): method testGeod3Solve (line 274) | def testGeod3Solve(self, Geodesic3Solve): method testTriaxial3 (line 308) | def testTriaxial3(self, module): method testTriaxial5 (line 468) | def testTriaxial5(self, module): method testTriaxum5 (line 644) | def testTriaxum5(self): FILE: test/testUnits.py class Tests (line 19) | class Tests(TestsBase): method testUnit (line 21) | def testUnit(self, U, arg, known=False): method testUnits (line 84) | def testUnits(self): FILE: test/testUps.py class Tests (line 15) | class Tests(TestsBase): method testUps (line 17) | def testUps(self, LL): FILE: test/testUtily.py class Tests (line 34) | class Tests(TestsBase): method testUtily (line 36) | def testUtily(self): # MCCABE 14 FILE: test/testUtm.py class Tests (line 14) | class Tests(TestsBase): method testUtm (line 16) | def testUtm(self, LL): FILE: test/testUtmTMcoords.py function testUtmTMcoords (line 15) | def testUtmTMcoords(name): FILE: test/testUtmUps.py class Tests (line 15) | class Tests(TestsBase): method testUtmUps (line 17) | def testUtmUps(self, LL): FILE: test/testUtmUpsTMcoords.py function testUtmUpsTMcoords (line 15) | def testUtmUpsTMcoords(name): FILE: test/testVectorial.py class Tests (line 20) | class Tests(TestsBase): method testIntersection3d3 (line 22) | def testIntersection3d3(self): method testNvectorBase (line 55) | def testNvectorBase(self, module, **kwds): method testVectorial (line 153) | def testVectorial(self, module, Sph=False): # MCCABE 14 method testTrilaterate3d (line 373) | def testTrilaterate3d(self, module, Vector): method testTrilaterate2d2 (line 429) | def testTrilaterate2d2(self): method testTrilaterate3d2 (line 474) | def testTrilaterate3d2(self, Vector): FILE: test/testWebMercator.py class Tests (line 16) | class Tests(TestsBase): method testWebMercator (line 18) | def testWebMercator(self, LatLon, LatLonE): method _TableA1 (line 142) | def _TableA1(self, R, secs, *ns): FILE: test/testWgrs.py function _fstr (line 14) | def _fstr(floats, prec=6): class Tests (line 18) | class Tests(TestsBase): method testCodec3 (line 20) | def testCodec3(self, g, x, prec=4): method testCodec5 (line 26) | def testCodec5(self, g, x, prec=4): method testGeoref (line 32) | def testGeoref(self, LL): FILE: test/unitTestSuite.py class TestSuite (line 17) | class TestSuite(unittest.TestCase): method _run (line 23) | def _run(self, test, *argv): method test_Albers (line 28) | def test_Albers(self): method test_Angles (line 31) | def test_Angles(self): method test_Auxilats (line 34) | def test_Auxilats(self): method test_Azimuthal (line 37) | def test_Azimuthal(self): method test_Basics (line 40) | def test_Basics(self): method test_Booleans (line 43) | def test_Booleans(self): method test_Cartesian (line 46) | def test_Cartesian(self): method test_Classes (line 49) | def test_Classes(self): method test_Clipy (line 52) | def test_Clipy(self): method test_Constants (line 55) | def test_Constants(self): method test_Css (line 58) | def test_Css(self): method test_Datums (line 61) | def test_Datums(self): method test_Deprecated (line 64) | def test_Deprecated(self): method test_Dms (line 67) | def test_Dms(self): method test_Ecef (line 70) | def test_Ecef(self): method test_Elevations (line 73) | def test_Elevations(self): method test_Ellipses (line 76) | def test_Ellipses(self): method test_Ellipsoidal (line 79) | def test_Ellipsoidal(self): method test_EllipsoidalGeodTest (line 82) | def test_EllipsoidalGeodTest(self): method test_Ellipsoids (line 85) | def test_Ellipsoids(self): method test_Elliptic (line 88) | def test_Elliptic(self): method test_Espg (line 91) | def test_Espg(self): method test_Errors (line 94) | def test_Errors(self): method test_Etm (line 97) | def test_Etm(self): method test_EtmTMcoords (line 100) | def test_EtmTMcoords(self): method test_ExactTMcoords (line 103) | def test_ExactTMcoords(self): method test_Fmath (line 106) | def test_Fmath(self): method test_Formy (line 109) | def test_Formy(self): method test_Frechet (line 112) | def test_Frechet(self): method test_Frozen (line 115) | def test_Frozen(self): method test_Fstats (line 118) | def test_Fstats(self): method test_Fsums (line 121) | def test_Fsums(self): method test_Gars (line 124) | def test_Gars(self): method test_Geohash (line 127) | def test_Geohash(self): method test_Geodesici (line 130) | def test_Geodesici(self): method test_Geodesicx (line 133) | def test_Geodesicx(self): method test_Geoids (line 136) | def test_Geoids(self): method test_GreatCircle (line 141) | def test_GreatCircle(self): method test_Hausdorff (line 144) | def test_Hausdorff(self): method test_Heights (line 147) | def test_Heights(self): method test_Interns (line 150) | def test_Interns(self): method test_Iters (line 153) | def test_Iters(self): method test_Karney (line 156) | def test_Karney(self): method test_KarneySigns (line 159) | def test_KarneySigns(self): method test_Ktm (line 162) | def test_Ktm(self): method test_LatLonBase (line 165) | def test_LatLonBase(self): method test_LatLon (line 168) | def test_LatLon(self): method test_Lazily (line 171) | def test_Lazily(self): method test_Lcc (line 174) | def test_Lcc(self): method test_Ltp (line 177) | def test_Ltp(self): method test_LtpTuples (line 180) | def test_LtpTuples(self): method test_Mgrs (line 183) | def test_Mgrs(self): method test_Modules (line 186) | def test_Modules(self): method test_Named (line 189) | def test_Named(self): method test_NamedTuples (line 192) | def test_NamedTuples(self): method test_NavlabExamples (line 195) | def test_NavlabExamples(self): method test_Osgr (line 198) | def test_Osgr(self): method test_Points (line 201) | def test_Points(self): method test_Props (line 204) | def test_Props(self): method test_Resections (line 207) | def test_Resections(self): method test_Rhumb_aux_ (line 210) | def test_Rhumb_aux_(self): method test_Rhumb_ekx (line 213) | def test_Rhumb_ekx(self): method test_Routes (line 216) | def test_Routes(self): method test_Simplify (line 219) | def test_Simplify(self): method test_Spherical (line 222) | def test_Spherical(self): method test_Streprs (line 225) | def test_Streprs(self): method test_TMcoords (line 228) | def test_TMcoords(self): method test_Trf (line 231) | def test_Trf(self): method test_Triaxials (line 234) | def test_Triaxials(self): method test_Units (line 237) | def test_Units(self): method test_Ups (line 240) | def test_Ups(self): method test_Utily (line 243) | def test_Utily(self): method test_Utm (line 246) | def test_Utm(self): method test_UtmTMcoords (line 249) | def test_UtmTMcoords(self): method test_UtmUps (line 252) | def test_UtmUps(self): method test_UtmUpsTMcoords (line 255) | def test_UtmUpsTMcoords(self): method test_Vectorial (line 258) | def test_Vectorial(self): method test_WebMercator (line 261) | def test_WebMercator(self): method test_Wgrs (line 264) | def test_Wgrs(self): method test_Ztotal (line 267) | def test_Ztotal(self):