Package pygeodesy
[frames] | no frames]

Package pygeodesy

A pure Python implementation of geodesy tools for various ellipsoidal and spherical earth models using precision trigonometric, vector-based, exact, elliptic and approximate methods for geodetic (lat-/longitude) and geocentric (ECEF cartesian) coordinates.

Transcoded from JavaScript originals by Chris Veness (C) 2005-2019 and from several C++ classes by Charles F.F. Karney (C) 2008-2021 and published under the same MIT License**.

There are four modules for ellipsoidal earth models, ellipsoidalExact, -Karney, -Vincenty and -Nvector and two for spherical ones, sphericalTrigonometry and -Nvector. Each module provides a geodetic LatLon and a geocentric Cartesian class with methods and functions to compute distance, surface area, perimeter, initial and final bearing, intermediate and nearest points, circle intersections, path intersections, 3-point resections, trilateration (by intersection, by overlap and in 3d), conversions and unrolling, among other things. For more information and further details see the documentation, the descriptions of Latitude/Longitude, Vincenty and Vector-based geodesy, the original JavaScript source or docs and Karney's Python geographiclib and C++ GeographicLib.

Also included are modules for conversions to and from Cassini-Soldner, ECEF (Earth-Centered, Earth-Fixed cartesian), UPS (Universal Polar Stereographic), UTM (Exact and Universal Transverse Mercator) and Web Mercator (Pseudo-Mercator) coordinates, MGRS (NATO Military Grid Reference System) and OSGR (British Ordinance Survery Grid Reference) grid references, TRF (Terrestrial Reference Frames) and modules to encode and decode EPSG, Geohashes, Georefs (WGRS) and Garefs (GARS).

Other modules provide Albers equal-area projections, equidistant and other azimuthal projections, Lambert conformal conic projections and positions, functions to clip a path or polygon of LatLon points using the Cohen-Sutherland, the Liang-Barsky and the Sutherland-Hodgman methods, functions to simplify or linearize a path of LatLon points (or a NumPy array), including implementations of the Ramer-Douglas-Peucker the Visvalingam-Whyatt and the Reumann-Witkam algorithms and modified versions of the former. Other classes interpolate the height of LatLon points and Geoid models or compute various Fréchet or Hausdorff distances.

Installation

To install PyGeodesy, type pip install PyGeodesy or easy_install PyGeodesy in a terminal or command window.

Alternatively, download PyGeodesy-yy.m.d.zip from PyPI or GitHub, unzip the downloaded file, cd to directory Pygeodesy-yy.m.d and type python[3] setup.py install.

To run all PyGeodesy tests, type python[3] setup.py test or type python[3] test/run.py or type python[3] test/unitTestSuite.py before or after installation.

Dependencies

Installation of Karney's Python package geographiclib is optional, but required to use modules ellipsoidalKarney and css, azimuthal classes EquidistantKarney and GnomonicKarney and the HeightIDWkarney interpolator.

Both numpy and scipy must be installed for most Geoid... and Height... interpolators, except GeoidKarney and the HeightIDW... ones.

Functions and LatLon methods circin6, circum3, circum4_, soddy4, trilaterate3d2 and trilaterate5 require numpy.

Modules ellipsoidalGeodSolve and geodsolve and azimuthal classes EquidistantGeodSolve and GnomonicGeodSolve depend on Karney's C++ utility GeodSolve to be executable.

Documentation

In addition to the pygeodesy package, the PyGeodesy distribution files contain the tests, the test results (on macOS only) and the complete documentation (generated by Epydoc using command line: epydoc --html --no-private --no-source --name=PyGeodesy --url=... -v pygeodesy).

Tests

The tests have been run with Python 3.10.4 (with geographiclib 2.0), Python 3.9.6 (with numpy 1.21.2), Python 3.8.10 (with geographiclib 1.52, GeodSolve 1.51, numpy 1.19.2 and scipy 1.5.2) and Python 2.7.18 (with GeodSolve 1.51, all on macOS 12.3.1 Monterey and in 64-bit only. The tests are run with and without lazy import for Python 3 and with command line option -W always and env var PYGEODESY_WARNINGS=on for all Python versions. The results of only those tests are included in the distribution files.

Python 3.10.4 and 3.9.6 run on Apple Silicon (arm64 natively), all other Python versions run on Intel (x86_64) or Intel emulation ("arm64_x86_64", see function pygeodesy.machine).

Test coverage has been measured with coverage 4.5.4 using Python 3.10.4 (with geographiclib 2.0), Python 3.9.6 (with numpy 1.21.2), Python 3.8.10 (with geographiclib 1.52, numpy 1.19.2 and scipy 1.5.2) and Python 2.7.18 (GeodSolve). The complete coverage report in HTML and a PDF summary are included in the distribution files.

The tests also ran with Python 3.10.4 or 3.9.9 (and geographiclib 1.52) on Debian 11 in 64-bit only and with Python 3.9.6, 3.8.0 and 2.7.17 (all with geographiclib 1.52) on Windows Server 2012R2 in 64- and/or 32-bit.

A single-File and single-Directory application with pygeodesy has been bundled using PyInstaller 3.4 and 64-bit Python 3.7.3 on macOS 10.13.6 High Sierra.

Previously, the tests were run with Python 3.10.1-3, 3.9.1, 3.8.7, 3.7.1, 2.7.15, PyPy 7.3.1 (Python 3.6.9) and PyPy 7.1.1 (Python 2.7.13) (and geographiclib 1.52 and numpy 1.16.3, 1.16.4, 1.16.6, 1.19.0, 1.19.4 or 1.19.5) on Ubuntu 16.04, with Python 3.10.0-1, 3.9.0-5, 3.8.0-6, 3.7.2-6, 3.7.0, 3.6.2-5, 3.5.3, 2.7.13-17, 2.7.10 and 2.6.9 (and numpy 1.19.0, 1.16.5, 1.16.2, 1.15.2, 1.14.0, 1.13.1, 1.8.0rc1 or 1.6.2 and scipy 1.5.0), PyPy 7.3.0 (Python 2.7.13 and 3.6.9), PyPy 6.0.0 (Python 2.7.13 and 3.5.3) and Intel-Python 3.5.3 (and numpy 1.11.3) on macOS 12.1-2.1 Monterey, 11.0-5.2-6.1 Big Sur (aka 10.16), 10.15.3, 10.15.5-7 Catalina, macOS 10.14 Mojave, macOS 10.13.6 High Sierra, macOS 10.12 Sierra, MacOS X 10.11 El Capitan and/or MacOS X 10.10 Yosemite, with Pythonista3.2 (with geographiclib 1.50 or 1.49 and numpy 1.8.0) on iOS 14.4.2, 11.4.1, 12.0-3 on iPad4, iPhone6 and/or iPhone10, with Pythonista 3.1 on iOS 10.3.3, 11.0.3, 11.1.2 and 11.3 on iPad4, all in 64-bit only and with 32-bit Python 2.7.14 on Windows 10 Pro and with 32-bit Python 2.6.6 on Windows XP SP3.

Notes

All Python source code has been statically checked with PyChecker, PyFlakes, PyCodeStyle (formerly Pep8) and McCabe using Python 2.7.18 and with Flake8 using Python 3.10.4, both in 64-bit on macOS 12.3.1 Monterey.

For a summary of all Karney-based functionality in pygeodesy, see module karney.

In Python 2, symbols S_DEG, S_MIN, S_SEC, S_RAD and S_SEP may be multi-byte, non-ascii characters and if so, not unicode.

Some function and method names differ from the JavaScript version. In such cases documentation tag JS name: shows the original JavaScript name.

Env vars

The following environment variables are observed by PyGeodesy:

plus during development:

License

**) Copyright (C) 2016-2022 -- mrJean1 at Gmail -- All Rights Reserved.

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


Version: 22.05.05

Submodules

Classes
  LazyImportError
Raised if lazy import is not supported, disabled or failed some other way.
  VincentyError
Error raised from Vincenty's direct and inverse methods for coincident points or lack of convergence.
  Epsg
EPSG class, a named int.
  EPSGError
EPSG encode, decode or other Epsg issue.
  Garef
Garef class, a named str.
  GARSError
Global Area Reference System (GARS) encode, decode or other Garef issue.
  Geohash
Geohash class, a named str.
  GeohashError
Geohash encode, decode or other Geohash issue.
  Neighbors8Dict
8-Dict (N, NE, E, SE, S, SW, W, NW) of Geohashes, providing key and attribute access to the items.
  Resolutions2Tuple
2-Tuple (res1, res2) with the primary (longitudinal) and secondary (latitudinal) resolution, both in degrees.
  Georef
Georef class, a named str.
  WGRSError
World Geographic Reference System (WGRS) encode, decode or other Georef issue.
  Aer
Local Azimuth-Elevation-Range (AER) in a local tangent plane.
  Aer4Tuple
4-Tuple (azimuth, elevation, slantrange, ltp), all in meter except ltp.
  Albers7Tuple
7-Tuple (x, y, lat, lon, gamma, scale, datum), in meter, meter, degrees90, degrees180, degrees360, scalar and Datum where (x, y) is the projected, (lat, lon) the geodetic location, gamma the meridian convergence at point, the bearing of the y-axis measured clockwise from true North and scale is the azimuthal scale of the projection at point.
  AlbersEqualArea
An Albers equal-area (authalic) projection with a single standard parallel.
  AlbersEqualArea2
An Albers equal-area (authalic) projection with two standard parallels.
  AlbersEqualArea4
An Albers equal-area (authalic) projection specified by the sin and cos of both standard parallels.
  AlbersEqualAreaCylindrical
An AlbersEqualArea projection at lat=0 and k0=1 degenerating to the cylindrical-equal-area projection.
  AlbersEqualAreaNorth
An azimuthal AlbersEqualArea projection at lat=90 and k0=1 degenerating to the azimuthal LambertEqualArea projection.
  AlbersEqualAreaSouth
An azimuthal AlbersEqualArea projection at lat=-90 and k0=1 degenerating to the azimuthal LambertEqualArea projection.
  AlbersError
An AlbersEqualArea, AlbersEqualArea2, AlbersEqualArea4, AlbersEqualAreaCylindrical, AlbersEqualAreaNorth, AlbersEqualAreaSouth or Albers7Tuple issue.
  Attitude
The orientation of a plane or camera in space.
  Attitude4Tuple
4-Tuple (alt, tilt, yaw, roll) with altitude in (positive) meter and tilt, yaw and roll in degrees representing the attitude of a plane or camera.
  AttitudeError
An Attitude or Attitude4Tuple issue.
  Azimuthal7Tuple
7-Tuple (x, y, lat, lon, azimuth, scale, datum), in meter, meter, degrees90, degrees180, compass degrees, scalar and Datum where (x, y) is the easting and northing of a projected point, (lat, lon) the geodetic location, azimuth the azimuth, clockwise from true North and scale is the projection scale, either 1 / reciprocal or 1 or -1 in the Equidistant case.
  AzimuthalError
An azimuthal Equidistant, EquidistantKarney, Gnomonic, LambertEqualArea, Orthographic, Stereographic or Azimuthal7Tuple issue.
  Band
Named str representing a UTM/UPS band letter, unchecked.
  Bearing
Named float representing a bearing in compass degrees from (true) North.
  Bearing2Tuple
2-Tuple (initial, final) bearings, both in compass degrees360.
  Bearing_
Named float representing a bearing in radians from compass degrees from (true) North.
  Bool
Named bool, a sub-class of int like Python's bool.
  Bounds2Tuple
2-Tuple (latlonSW, latlonNE) with the bounds' lower-left and upper-right corner as LatLon instance.
  Bounds4Tuple
4-Tuple (latS, lonW, latN, lonE) with the bounds' lower-left (LatS, LowW) and upper-right (latN, lonE) corner lat- and longitudes.
  CSSError
Cassini-Soldner (CSS) conversion or other Css issue.
  CassiniSoldner
Cassini-Soldner projection, a Python version of Karney's C++ class CassiniSoldner.
  Circin6Tuple
6-Tuple (radius, center, deltas, cA, cB, cC) with the radius, the trilaterated center and contact points of the inscribed aka In- circle of a triangle.
  Circle4Tuple
4-Tuple (radius, height, lat, beta) of the radius and height, both conventionally in meter of a parallel circle of latitude at (geodetic) latitude lat and the parametric (or reduced) auxiliary latitude beta, both in degrees90.
  Circum3Tuple
3-Tuple (radius, center, deltas) with the circumradius and trilaterated circumcenter of the circumcircle through 3 points (aka {Meeus}' Type II circle) or the radius and center of the smallest Meeus' Type I circle.
  Circum4Tuple
4-Tuple (radius, center, rank, residuals) with radius and center of a sphere least-squares fitted through given points and the rank and residuals -if any- from numpy.linalg.lstsq.
  ClipCS3Tuple
3-Tuple (start, end, index).
  ClipCS4Tuple
4-Tuple (start, end, i, j) for each edge of a clipped path with the start and end points (LatLon) of the portion of the edge inside or on the clip box and the indices i and j (int) of the edge start and end points in the original path.
  ClipError
Clip box or clip region issue.
  ClipLB6Tuple
6-Tuple (start, end, i, fi, fj, j) for each edge of the clipped path with the start and end points (LatLon) of the portion of the edge inside or on the clip box, indices i and j (both int) of the original path edge start and end points and fractional indices fi and fj (both FIx) of the start and end points along the edge of the original path.
  ClipSH3Tuple
3-Tuple (start, end, original) for each edge of a clipped polygon, the start and end points (LatLon) of the portion of the edge inside or on the clip region and original indicates whether the edge is part of the original polygon or part of the clip region (bool).
  Collins5Tuple
5-Tuple (pointP, pointH, a, b, c) with survey pointP, auxiliary pointH, each an instance of pointA's (sub-)class and triangle sides a, b and c in meter, conventionally.
  Conic
Lambert conformal conic projection (1- or 2-SP).
  CrossError
Error raised for zero or near-zero vectorial cross products, occurring for coincident or colinear points, paths or bearings.
  Css
Cassini-Soldner East-/Northing location.
  Curvature2Tuple
2-Tuple (meridional, prime_vertical) of radii of curvature, both in meter, conventionally.
  Datum
Ellipsoid and transform parameters for an earth model.
  Degrees
Named float representing a coordinate in degrees, optionally clipped.
  Degrees2
Named float representing a distance in degrees squared.
  Degrees_
Named Degrees representing a coordinate in degrees with optional limits low and high.
  Destination2Tuple
2-Tuple (destination, final), destination in LatLon and final bearing in compass degrees360.
  Destination3Tuple
3-Tuple (lat, lon, final), destination lat, lon in degrees90 respectively degrees180 and final bearing in compass degrees360.
  Direct9Tuple
9-Tuple (a12, lat2, lon2, azi2, s12, m12, M12, M21, S12) with arc length a12, angles lat2, lon2 and azimuth azi2 in degrees, distance s12 and reduced length m12 in meter and area S12 in meter squared.
  Distance
Named float representing a distance, conventionally in meter.
  Distance2Tuple
2-Tuple (distance, initial), distance in meter and initial bearing in compass degrees360.
  Distance3Tuple
3-Tuple (distance, initial, final), distance in meter and initial and final bearing, both in compass degrees360.
  Distance4Tuple
4-Tuple (distance2, delta_lat, delta_lon, unroll_lon2) with the distance in degrees squared, the latitudinal delta_lat = lat2 - lat1, the wrapped, unrolled and adjusted longitudinal delta_lon = lon2 - lon1 and unroll_lon2, the unrolled or original lon2.
  Distance_
Named float with optional low and high limits representing a distance, conventionally in meter.
  ETMError
Exact Transverse Mercator (ETM) parse, projection or other Etm issue.
  EasNor2Tuple
2-Tuple (easting, northing), both in meter, conventionally.
  EasNor3Tuple
3-Tuple (easting, northing, height), all in meter, conventionally.
  EasNorAziRk4Tuple
4-Tuple (easting, northing, azimuth, reciprocal) for the Cassini-Soldner location with easting and northing in meters and the azimuth of easting direction and reciprocal of azimuthal northing scale, both in degrees.
  EasNorAziRkEqu6Tuple
6-Tuple (easting, northing, azimuth, reciprocal, equatorarc, equatorazimuth) for the Cassini-Soldner location with easting and northing in meters and the azimuth of easting direction, reciprocal of azimuthal northing scale, equatorarc and equatorazimuth, all in degrees.
  EasNorExact4Tuple
4-Tuple (easting, northing, convergence, scale) in meter, meter, degrees and scalar.
  EasNorRadius3Tuple
3-Tuple (easting, northing, radius), all in meter.
  Easting
Named float representing an easting, conventionally in meter.
  Ecef9Tuple
9-Tuple (x, y, z, lat, lon, height, C, M, datum) with geocentric x, y and z plus geodetic lat, lon and height, case C (see the Ecef*.reverse methods) and optionally, the rotation matrix M (EcefMatrix) and datum, with lat and lon in degrees and x, y, z and height in meter, conventionally.
  EcefCartesian
DEPRECATED, use class LocalCartesian.
  EcefError
An ECEF or Ecef* related issue.
  EcefFarrell21
Conversion between geodetic and geocentric, aka Earth-Centered, Earth-Fixed (ECEF) coordinates based on Jay A. Farrell's Table 2.1, page 29.
  EcefFarrell22
Conversion between geodetic and geocentric, aka Earth-Centered, Earth-Fixed (ECEF) coordinates based on Jay A. Farrell's Table 2.2, page 30.
  EcefKarney
Conversion between geodetic and geocentric, aka Earth-Centered, Earth-Fixed (ECEF) coordinates transcoded from Karney's C++ Geocentric methods.
  EcefMatrix
A rotation matrix.
  EcefSudano
Conversion between geodetic and geocentric, aka Earth-Centered, Earth-Fixed (ECEF) coordinates based on John J. Sudano's paper.
  EcefVeness
Conversion between geodetic and geocentric, aka Earth-Centered, Earth-Fixed (ECEF) coordinates transcoded from Chris Veness' JavaScript classes LatLonEllipsoidal, Cartesian.
  EcefYou
Conversion between geodetic and geocentric, aka Earth-Centered, Earth-Fixed (ECEF) coordinates using Rey-Jer You's transformation.
  Elevation2Tuple
2-Tuple (elevation, data_source) in meter and str.
  Ellipsoid
Ellipsoid with equatorial and polar radii, flattening, inverse flattening and other, often used, cached attributes, supporting oblate and prolate ellipsoidal and spherical earth models.
  Ellipsoid2
An Ellipsoid specified by equatorial radius and flattening.
  Elliptic
Elliptic integrals and functions.
  Elliptic3Tuple
3-Tuple (sn, cn, dn) all scalar.
  EllipticError
Elliptic integral, function, convergence or other Elliptic issue.
  Enu
Local Eeast-North-Up (ENU) location in a local tangent plane.
  Enu4Tuple
4-Tuple (east, north, up, ltp), in meter except ltp.
  Epoch
Named epoch with optional low and high limits representing a fractional calendar year.
  Equidistant
Azimuthal equidistant projection for the sphere***, see Snyder, pp 195-197 and MathWorld-Wolfram.
  EquidistantExact
Azimuthal equidistant projection, a Python version of Karney's C++ class AzimuthalEquidistant, based on exact geodesic classes GeodesicExact and GeodesicLineExact.
  EquidistantGeodSolve
Azimuthal equidistant projection, a Python version of Karney's C++ class AzimuthalEquidistant, based on (exact) geodesic wrappers GeodesicSolve and GeodesicLineSolve and intended for testing purposes only.
  EquidistantKarney
Azimuthal equidistant projection, a Python version of Karney's C++ class AzimuthalEquidistant, requiring package geographiclib to be installed.
  Etm
Exact Transverse Mercator (ETM) coordinate, a sub-class of Utm, a Universal Transverse Mercator (UTM) coordinate using the ExactTransverseMercator projection for highest accuracy.
  ExactTransverseMercator
A Python version of Karney's TransverseMercatorExact C++ class, a numerically exact transverse Mercator projection, here referred to as TMExact.
  FIx
A named Fractional Index, an int or float index into a list or tuple of points, typically.
  Fcook
Cook's RunningStats computing the running mean, median and (sample) kurtosis, skewness, variance, standard deviation and Jarque-Bera normality.
  Fdot
Precision dot product.
  Feet
Named float representing a distance or length in feet.
  Fhorner
Precision polynomial evaluation using the Horner form.
  Flinear
Cook's RunningRegression computing the running slope, intercept and correlation of a linear regression.
  Float
Named float.
  Float_
Named float with optional low and high limit.
  Footprint5Tuple
5-Tuple (center, upperleft, upperight, loweright, lowerleft) with the center and 4 corners of a local projection of a Frustum, each an Xyz4Tuple.
  Fpolynomial
Precision polynomial evaluation.
  Frechet
Frechet base class, requires method Frechet.distance to be overloaded.
  Frechet6Tuple
6-Tuple (fd, fi1, fi2, r, n, units) with the discrete Fréchet distance fd, fractional indices fi1 and fi2 as FIx, the recursion depth r, the number of distances computed n and the units class or class or name of the distance units.
  FrechetCosineAndoyerLambert
Compute the Frechet distance based on the angular distance in radians from function pygeodesy.cosineAndoyerLambert_.
  FrechetCosineForsytheAndoyerLambert
Compute the Frechet distance based on the angular distance in radians from function pygeodesy.cosineForsytheAndoyerLambert_.
  FrechetCosineLaw
Compute the Frechet distance based on the angular distance in radians from function pygeodesy.cosineLaw_.
  FrechetDegrees
Frechet base class for distances in degrees from LatLon points in degrees.
  FrechetDistanceTo
Compute the Frechet distance based on the distance from the points' LatLon.distanceTo method, conventionally in meter.
  FrechetEquirectangular
Compute the Frechet distance based on the equirectangular distance in radians squared like function pygeodesy.equirectangular_.
  FrechetError
Fréchet issue.
  FrechetEuclidean
Compute the Frechet distance based on the Euclidean distance in radians from function pygeodesy.euclidean_.
  FrechetExact
Compute the Frechet distance based on the angular distance in degrees from method GeodesicExact.Inverse.
  FrechetFlatLocal
Compute the Frechet distance based on the angular distance in radians squared like function pygeodesy.flatLocal_/pygeodesy.hubeny_.
  FrechetFlatPolar
Compute the Frechet distance based on the angular distance in radians from function flatPolar_.
  FrechetHaversine
Compute the Frechet distance based on the angular distance in radians from function pygeodesy.haversine_.
  FrechetHubeny
Compute the Frechet distance based on the angular distance in radians squared like function pygeodesy.flatLocal_/pygeodesy.hubeny_.
  FrechetKarney
Compute the Frechet distance based on the angular distance in degrees from Karney's geographiclib Geodesic Inverse method.
  FrechetRadians
Frechet base class for distances in radians or radians squared from LatLon points converted from degrees to radians.
  FrechetThomas
Compute the Frechet distance based on the angular distance in radians from function pygeodesy.thomas_.
  FrechetVincentys
Compute the Frechet distance based on the angular distance in radians from function pygeodesy.vincentys_.
  Frustum
A rectangular pyramid, typically representing a camera's field-of-view (fov) and the intersection with (or projection to) a local tangent plane.
  Fsum
Precision floating point running summation similar to standard Python's math.fsum.
  Fsum2Tuple
2-Tuple (fsum, residual) with the precision running fsum and the residual, the sum of the remaining partials.
  Fwelford
Welford's accumulator computing the running mean, (sample) variance and standard deviation.
  GDict
Basic dict with both key and attribute access to the dict items.
  GeodSolve12Tuple
12-Tuple (lat1, lon1, azi1, lat2, lon2, azi2, s12, a12, m12, M12, M21, S12) with angles lat1, lon1, azi1, lat2, lon2 and azi2 and arc a12 all in degrees, initial azi1 and final azi2 forward azimuths, distance s12 and reduced length m12 in meter, area S12 in meter squared and geodesic scale factors M12 and M21, both scalar, see GeodSolve.
  GeodesicAreaExact
Area and perimeter of a geodesic polygon, an enhanced version of Karney's Python class PolygonArea using the more accurate surface area.
  GeodesicError
Error raised for pygeodesy.geodesicx lack of convergence or other pygeodesy.geodesicx or pygeodesy.karney issues.
  GeodesicExact
A pure Python version of Karney's C++ class GeodesicExact, modeled after Karney's Python class Geodesic.
  GeodesicLineExact
A pure Python version of Karney's C++ class GeodesicLineExact, modeled after Karney's Python class GeodesicLine.
  GeodesicLineSolve
Wrapper to invoke Karney's GeodSolve as an Exact version of Karney's Python class GeodesicLine.
  GeodesicSolve
Wrapper to invoke Karney's GeodSolve as an Exact version of Karney's Python class Geodesic.
  GeoidError
Geoid interpolator Geoid... or interpolation issue.
  GeoidG2012B
Geoid height interpolator for GEOID12B Model grids CONUS, Alaska, Hawaii, Guam and Northern Mariana Islands, Puerto Rico and U.S. Virgin Islands and American Samoa based on SciPy RectBivariateSpline or interp2d interpolation.
  GeoidHeight2Tuple
2-Tuple (height, model_name), geoid height in meter and model_name as str.
  GeoidHeight5Tuple
5-Tuple (lat, lon, egm84, egm96, egm2008) for GeoidHeights.dat tests with the heights for 3 different EGM grids at degrees90 and degrees180 degrees (after converting lon from original 0 <= EasterLon <= 360).
  GeoidKarney
Geoid height interpolator for Karney's GeographicLib Earth Gravitational Model (EGM) geoid egm*.pgm datasets using bilinear or cubic interpolation and caching in pure Python, transcoded from Karney's C++ class Geoid.
  GeoidPGM
Geoid height interpolator for Karney's GeographicLib Earth Gravitational Model (EGM) geoid egm*.pgm datasets but based on SciPy RectBivariateSpline or interp2d interpolation.
  Gnomonic
Azimuthal gnomonic projection for the sphere***, see Snyder, pp 164-168 and MathWorld-Wolfram.
  GnomonicExact
Azimuthal gnomonic projection, a Python version of Karney's C++ class Gnomonic, based on exact geodesic classes GeodesicExact and GeodesicLineExact.
  GnomonicGeodSolve
Azimuthal gnomonic projection, a Python version of Karney's C++ class Gnomonic, based on (exact) geodesic wrappers GeodesicSolve and GeodesicLineSolve and intended for testing purposes only.
  GnomonicKarney
Azimuthal gnomonic projection, a Python version of Karney's C++ class Gnomonic, requiring package geographiclib to be installed.
  Hausdorff
Hausdorff base class, requires method Hausdorff.distance to be overloaded.
  Hausdorff6Tuple
6-Tuple (hd, i, j, mn, md, units) with the Hausdorff distance hd, indices i and j, the total count mn, the mean Hausdorff distance md and the class or name of both distance units.
  HausdorffCosineAndoyerLambert
Compute the Hausdorff distance based on the angular distance in radians from function pygeodesy.cosineAndoyerLambert_.
  HausdorffCosineForsytheAndoyerLambert
Compute the Hausdorff distance based on the angular distance in radians from function pygeodesy.cosineForsytheAndoyerLambert_.
  HausdorffCosineLaw
Compute the Hausdorff distance based on the angular distance in radians from function pygeodesy.cosineLaw_.
  HausdorffDegrees
Hausdorff base class for distances from LatLon points in degrees.
  HausdorffDistanceTo
Compute the Hausdorff distance based on the distance from the points' LatLon.distanceTo method, conventionally in meter.
  HausdorffEquirectangular
Compute the Hausdorff distance based on the equirectangular distance in radians squared like function pygeodesy.equirectangular_.
  HausdorffError
Hausdorff issue.
  HausdorffEuclidean
Compute the Hausdorff distance based on the Euclidean distance in radians from function pygeodesy.euclidean_.
  HausdorffExact
Compute the Hausdorff distance based on the angular distance in degrees from method GeodesicExact.Inverse.
  HausdorffFlatLocal
Compute the Hausdorff distance based on the angular distance in radians squared like function pygeodesy.flatLocal_/pygeodesy.hubeny_.
  HausdorffFlatPolar
Compute the Hausdorff distance based on the angular distance in radians from function pygeodesy.flatPolar_.
  HausdorffHaversine
Compute the Hausdorff distance based on the angular distance in radians from function pygeodesy.haversine_.
  HausdorffHubeny
Compute the Hausdorff distance based on the angular distance in radians squared like function pygeodesy.flatLocal_/pygeodesy.hubeny_.
  HausdorffKarney
Compute the Hausdorff distance based on the angular distance in degrees from Karney's geographiclib Geodesic Inverse method.
  HausdorffRadians
Hausdorff base class for distances from LatLon points converted from degrees to radians.
  HausdorffThomas
Compute the Hausdorff distance based on the angular distance in radians from function pygeodesy.thomas_.
  HausdorffVincentys
Compute the Hausdorff distance based on the angular distance in radians from function pygeodesy.vincentys_.
  Height
Named float representing a height, conventionally in meter.
  HeightCubic
Height interpolator based on SciPy interp2d kind='cubic'.
  HeightError
Height interpolator Height... or interpolation issue.
  HeightIDW
DEPRECATED, use class HeightIDWeuclidean.
  HeightIDW2
DEPRECATED, use class HeightIDWequirectangular.
  HeightIDW3
DEPRECATED, use class HeightIDWhaversine.
  HeightIDWcosineAndoyerLambert
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in radians from function pygeodesy.cosineAndoyerLambert_.
  HeightIDWcosineForsytheAndoyerLambert
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in radians from function pygeodesy.cosineForsytheAndoyerLambert_.
  HeightIDWcosineLaw
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in radians from function pygeodesy.cosineLaw_.
  HeightIDWdistanceTo
Height interpolator using Inverse Distance Weighting (IDW) and the distance from the points' LatLon.distanceTo method, conventionally in meter.
  HeightIDWequirectangular
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in radians squared like function pygeodesy.equirectangular_.
  HeightIDWeuclidean
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in radians from function pygeodesy.euclidean_.
  HeightIDWflatLocal
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in radians squared like function pygeodesy.flatLocal_/pygeodesy.hubeny_.
  HeightIDWflatPolar
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in radians from function pygeodesy.flatPolar_.
  HeightIDWhaversine
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in radians from function pygeodesy.haversine_.
  HeightIDWhubeny
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in radians squared like function pygeodesy.flatLocal_/pygeodesy.hubeny_.
  HeightIDWkarney
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in degrees from Karney's geographiclib Geodesic Inverse method.
  HeightIDWthomas
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in radians from function pygeodesy.thomas_.
  HeightIDWvincentys
Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in radians from function pygeodesy.vincentys_.
  HeightLSQBiSpline
Height interpolator using SciPy LSQSphereBivariateSpline.
  HeightLinear
Height interpolator based on SciPy interp2d kind='linear'.
  HeightSmoothBiSpline
Height interpolator using SciPy SmoothSphereBivariateSpline.
  Int
Named int.
  Int_
Named int with optional limits low and high.
  Intersection3Tuple
3-Tuple (point, outside1, outside2) of an intersection point and outside1, the position of the point, -1 if before the start, +1 if after the end and 0 if on or between the start and end point of the first line.
  IntersectionError
Error raised for path or circle intersection issues.
  Inverse10Tuple
10-Tuple (a12, s12, salp1, calp1, salp2, calp2, m12, M12, M21, S12) with arc length a12 in degrees, distance s12 and reduced length m12 in meter, area S12 in meter squared and the sines salp1, salp2 and cosines calp1, calp2 of the initial 1 and final 2 foward azimuths.
  LCCError
Lambert Conformal Conic LCC or other Lcc issue.
  Lam
Named float representing a longitude in radians.
  Lam_
Named float representing a longitude in radians converted from degrees.
  LambertEqualArea
Lambert-equal-area projection for the sphere*** (aka Lambert zenithal equal-area projection, see Snyder, pp 185-187 and MathWorld-Wolfram.
  Lat
Named float representing a latitude in degrees.
  LatLon2PsxyIter
Iterate and convert for points with optional loop-back and copies.
  LatLon2Tuple
2-Tuple (lat, lon) in degrees90 and degrees180.
  LatLon2psxy
Wrapper for LatLon points as "on-the-fly" pseudo-xy coordinates.
  LatLon3Tuple
3-Tuple (lat, lon, height) in degrees90, degrees180 and meter, conventionally.
  LatLon4Tuple
4-Tuple (lat, lon, height, datum) in degrees90, degrees180, meter and Datum.
  LatLonAziRk4Tuple
4-Tuple (lat, lon, azimuth, reciprocal), all in degrees where azimuth is the azimuth of easting direction and reciprocal the reciprocal of azimuthal northing scale.
  LatLonDatum3Tuple
3-Tuple (lat, lon, datum) in degrees90, degrees180 and Datum.
  LatLonDatum5Tuple
5-Tuple (lat, lon, datum, convergence, scale) in degrees90, degrees180, Datum, degrees and float.
  LatLonExact4Tuple
4-Tuple (lat, lon, convergence, scale) in degrees180, degrees180, degrees and scalar.
  LatLonPrec3Tuple
3-Tuple (lat, lon, precision) in degrees, degrees and int.
  LatLonPrec5Tuple
5-Tuple (lat, lon, precision, height, radius) in degrees, degrees, int and height or radius in meter (or None if missing).
  LatLon_
Low-overhead LatLon class for Numpy2LatLon and Tuple2LatLon.
  Lat_
Named float representing a latitude in degrees within limits low and high.
  Lcc
Lambert conformal conic East-/Northing location.
  LenError
Error raised for mis-matching len values.
  LimitError
Error raised for lat- or longitudinal deltas exceeding the limit in functions pygeodesy.equirectangular and pygeodesy.equirectangular_ and several nearestOn* and simplify* functions or methods.
  Local9Tuple
9-Tuple (x, y, z, lat, lon, height, ltp, ecef, M) with local x, y, z all in meter, geodetic lat, lon, height, local tangent plane ltp (Ltp), ecef (Ecef9Tuple) with geocentric x, y, z, geodetic lat, lon, height and concatenated rotation matrix M (EcefMatrix) or None.
  LocalCartesian
Conversion between geodetic (lat, lon, height) and local cartesian (x, y, z) coordinates with geodetic origin (lat0, lon0, height0), transcoded from Karney's C++ class LocalCartesian.
  LocalError
A LocalCartesian or Ltp related issue.
  Lon
Named float representing a longitude in degrees.
  Lon_
Named float representing a longitude in degrees within limits low and high.
  Ltp
A local tangent plan LTP, a sub-class of LocalCartesian with configurable ECEF converter and without optional rotation matrix.
  MGRSError
Military Grid Reference System (MGRS) parse or other Mgrs issue.
  Meeus2Tuple
2-Tuple (radius, Type) with radius and Meeus' Type of the smallest circle containing 3 points.
  Meter
Named float representing a distance or length in meter.
  Meter2
Named float representing an area in meter squared.
  Meter3
Named float representing a volume in meter cubed.
  Meter_
Named float representing a distance or length in meter.
  Mgrs
Military Grid Reference System (MGRS/NATO) references, with method to convert to UTM coordinates.
  Mgrs4Tuple
4-Tuple (zone, digraph, easting, northing), zone and digraph as str, easting and northing in meter.
  Mgrs6Tuple
6-Tuple (zone, digraph, easting, northing, band, datum), zone, digraph and band as str, easting and northing in meter and datum a Datum.
  NearestOn2Tuple
2-Tuple (closest, fraction) of the closest point on and fraction along a line (segment) between two points.
  NearestOn3Tuple
3-Tuple (closest, distance, angle) of the closest point on the polygon, either a LatLon instance or a LatLon3Tuple(lat, lon, height) and the distance and angle to the closest point are in meter respectively compass degrees360.
  NearestOn5Tuple
5-Tuple (lat, lon, distance, angle, height) all in degrees, except height.
  NearestOn6Tuple
6-Tuple (closest, distance, fi, j, start, end) with the closest point, the distance in meter, conventionally and the start and end point of the path or polygon edge.
  NearestOn8Tuple
8-Tuple (closest, distance, fi, j, start, end, initial, final), like NearestOn6Tuple but extended with the initial and the final bearing at the reference respectively the closest point, both in compass degrees.
  Ned
Local North-Eeast-Down (NED) location in a local tangent plane.
  Ned3Tuple
3-Tuple (north, east, down).
  Ned4Tuple
4-Tuple (north, east, down, ltp), all in meter except ltp.
  Northing
Named float representing a northing, conventionally in meter.
  NumPyError
Error raised for NumPy errors.
  Number_
Named int representing a non-negative number.
  Numpy2LatLon
Wrapper for NumPy arrays as "on-the-fly" LatLon points.
  OSGRError
Ordinance Survey Grid References (OSGR) parse or other Osgr issue.
  Orthographic
Orthographic projection for the sphere***, see Snyder, pp 148-153 and MathWorld-Wolfram.
  Osgr
Ordinance Survey Grid References (OSGR) coordinate.
  PGMError
Issue parsing or cropping an egm*.pgm geoid dataset.
  ParseError
Error parsing degrees, radians or several other formats.
  Phi
Named float representing a latitude in radians.
  PhiLam2Tuple
2-Tuple (phi, lam) with latitude phi in radians[PI_2] and longitude lam in radians[PI].
  PhiLam3Tuple
3-Tuple (phi, lam, height) with latitude phi in radians[PI_2], longitude lam in radians[PI] and height in meter.
  PhiLam4Tuple
4-Tuple (phi, lam, height, datum) with latitude phi in radians[PI_2], longitude lam in radians[PI], height in meter and Datum.
  Phi_
Named float representing a latitude in radians converted from degrees.
  Point3Tuple
3-Tuple (x, y, ll) in meter, meter and LatLon.
  Points2Tuple
2-Tuple (number, points) with the number of points and -possible reduced- list or tuple of points.
  PointsError
Error for an insufficient number of points.
  PointsIter
Iterator for points with optional loop-back and copies.
  PolygonArea
For geographiclib compatibility, sub-class of GeodesicAreaExact.
  Precision_
Named int with optional low and high limits representing a precision.
  Property
  Property_RO
  Radians
Named float representing a coordinate in radians, optionally clipped.
  Radians2
Named float representing a distance in radians squared.
  Radians_
Named float representing a coordinate in radians with optional limits low and high.
  Radical2Tuple
2-Tuple (ratio, xline) of the radical ratio and radical xline, both scalar and 0.0 <= ratio <= 1.0
  Radii11Tuple
11-Tuple (rA, rB, rC, cR, rIn, riS, roS, a, b, c, s) with the Tangent circle radii rA, rB and rC, the circumradius cR, the Incircle radius rIn aka inradius, the inner and outer Soddy circle radii riS and roS and the sides a, b and c and semi-perimeter s of a triangle, all in meter conventionally.
  Radius
Named float representing a radius, conventionally in meter.
  Radius_
Named float with optional low and high limits representing a radius, conventionally in meter.
  RangeError
Error raised for lat- or longitude values outside the clip, clipLat, clipLon or limit range in function pygeodesy.clipDegrees, pygeodesy.clipRadians, pygeodesy.parse3llh, pygeodesy.parseDMS, pygeodesy.parseDMS2 or pygeodesy.parseRad.
  RefFrame
Terrestrial Reference Frame (TRF) parameters.
  RefFrameError
DEPRECATED, use class TRFError.
  ResectionError
Error raised for issues in pygeodesy.resections.
  ResidualError
Error raised for an operation involving a pygeodesy.sums.Fsum instance with a non-zero residual, integer or otherwise.
  Scalar
Named float representing a factor, fraction, scale, etc.
  Scalar_
Named float with optional low and high limits representing a factor, fraction, scale, etc.
  SciPyError
Error raised for SciPy errors.
  SciPyWarning
Error thrown for SciPy warnings.
  Shape2Tuple
2-Tuple (nrows, ncols), the number of rows and columns, both int.
  Soddy4Tuple
4-Tuple (radius, center, deltas, outer) with radius and trilaterated center of the inner Soddy circle and the radius of the outer Soddy circle.
  Stereographic
Stereographic projection for the sphere***, see Snyder, pp 157-160 and MathWorld-Wolfram.
  Str
Named str.
  Str_
Extended, callable str class, not nameable.
  Survey3Tuple
3-Tuple (PA, PB, PC) with distance from survey point P to each of the triangle corners A, B and C in meter, conventionally.
  TRFError
Terrestrial Reference Frame (TRF), Epoch, RefFrame or RefFrame conversion issue.
  Tienstra7Tuple
7-Tuple (pointP, A, B, C, a, b, c) with survey pointP, interior triangle angles A, B and C in degrees and triangle sides a, b and c in meter, conventionally.
  Transform
Helmert transformation.
  Transform7Tuple
7-Tuple (tx, ty, tz, s, sx, sy, sz) Helmert transformation with translations tx, ty and tz in millimeter, scale s in ppb and rotations sx, sy and sz in milliarcseconds.
  TriAngle4Tuple
4-Tuple (radA, radB, radC, rIn) with the interior angles at triangle corners A, B and C in radians and the InCircle radius rIn aka inradius in meter, conventionally.
  TriSide2Tuple
2-Tuple (a, radA) with triangle side a in meter, conventionally and angle radA at the opposite triangle corner in radians.
  TriSide4Tuple
4-Tuple (a, b, radC, d) with interior angle radC at triangle corner C in radianswith the length of triangle sides a and b and with triangle height d perpendicular to triangle side c, in the same units as triangle sides a and b.
  Triangle7Tuple
7-Tuple (A, a, B, b, C, c, area) with interior angles A, B and C in degrees, spherical sides a, b and c in meter and the area of a spherical triangle in square meter.
  Triangle8Tuple
8-Tuple (A, a, B, b, C, c, D, E) with interior angles A, B and C, spherical sides a, b and c, spherical deficit D and spherical excess E of a spherical triangle, all in radians.
  TriangleError
Error raised for triangle, inter- or resection issues.
  Trilaterate5Tuple
5-Tuple (min, minPoint, max, maxPoint, n) with min and max in meter, the corresponding trilaterated minPoint and maxPoint as LatLon and the number n.
  Tuple2LatLon
Wrapper for tuple sequences as "on-the-fly" LatLon points.
  UPSError
Universal Polar Stereographic (UPS) parse or other Ups issue.
  UTMError
Universal Transverse Mercator (UTM parse or other Utm issue.
  UTMUPSError
Universal Transverse Mercator/Universal Polar Stereographic (UTM/UPS) parse, validate or other issue.
  UnitError
Default exception for units issues.
  Ups
Universal Polar Stereographic (UPS) coordinate.
  Utm
Universal Transverse Mercator (UTM) coordinate.
  UtmUps2Tuple
2-Tuple (zone, hemipole) as int and str, where zone is 1..60 for UTM or 0 for UPS and hemipole 'N'|'S' is the UTM hemisphere or the UPS pole.
  UtmUps4Tuple
OBSOLETE, expect a UtmUps5Tuple from method Mgrs.toUtm(utm=None).
  UtmUps5Tuple
5-Tuple (zone, hemipole, easting, northing, band) as int, str, meter, meter and band letter, where zone is 1..60 for UTM or 0 for UPS, hemipole 'N'|'S' is the UTM hemisphere or the UPS pole and band is "" or the longitudinal UTM band 'C'|'D'|..|'W'|'X' or polar UPS band 'A'|'B'|'Y'|'Z'.
  UtmUps8Tuple
8-Tuple (zone, hemipole, easting, northing, band, datum, convergence, scale) as int, str, meter, meter, band letter, Datum, degrees and scalar, where zone is 1..60 for UTM or 0 for UPS, hemipole 'N'|'S' is the UTM hemisphere or the UPS pole and band is "" or the longitudinal UTM band 'C'|'D'|..|'W'|'X' or polar UPS band 'A'|'B'|'Y'|'Z'.
  UtmUpsLatLon5Tuple
5-Tuple (zone, band, hemipole, lat, lon) as int, str, str, degrees90 and degrees180, where zone is 1..60 for UTM or 0 for UPS, band is "" or the longitudinal UTM band 'C'|'D'|..|'W'|'X' or polar UPS band 'A'|'B'|'Y'|'Z' and hemipole 'N'|'S' is the UTM hemisphere or the UPS pole.
  Vector2Tuple
2-Tuple (x, y) of (geocentric) components, each in meter or the same units.
  Vector3Tuple
3-Tuple (x, y, z) of (geocentric) components, all in meter or the same units.
  Vector3d
Extended 3-D vector.
  Vector4Tuple
4-Tuple (x, y, z, h) of (geocentric) components, all in meter or the same units.
  VectorError
Vector3d, Cartesian* or *Nvector issues.
  WebMercatorError
Web Mercator (WM) parser or Wm issue.
  Wm
Web Mercator (WM) coordinate.
  Xyz4Tuple
4-Tuple (x, y, z, ltp), all in meter except ltp.
  XyzLocal
Local (x, y, z) in a local tangent plane (LTP) and base class for local Enu, Ned and Aer.
  Zone
Named int representing a UTM/UPS zone number.
  a_f2Tuple
2-Tuple (a, f) specifying an ellipsoid by equatorial radius a in meter and scalar flattening f.
  property_RO
Functions
 
DeprecationWarnings()
Have any DeprecationWarnings been reported or raised?
 
UtmUps(zone, hemipole, easting, northing, band='', datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., falsed=True, name='')
Class-like function to create a UTM/UPS coordinate.
 
a_b2e(a, b)
Return e, the 1st eccentricity for a given equatorial and polar radius.
 
a_b2e2(a, b)
Return e2, the 1st eccentricity squared for a given equatorial and polar radius.
 
a_b2e22(a, b)
Return e22, the 2nd eccentricity squared for a given equatorial and polar radius.
 
a_b2e32(a, b)
Return e32, the 3rd eccentricity squared for a given equatorial and polar radius.
 
a_b2f(a, b)
Return f, the flattening for a given equatorial and polar radius.
 
a_b2f2(a, b)
Return f2, the 2nd flattening for a given equatorial and polar radius.
 
a_b2f_(a, b)
Return f_, the inverse flattening for a given equatorial and polar radius.
 
a_b2n(a, b)
Return n, the 3rd flattening for a given equatorial and polar radius.
 
a_f2b(a, f)
Return b, the polar radius for a given equatorial radius and flattening.
 
a_f_2b(a, f_)
Return b, the polar radius for a given equatorial radius and inverse flattening.
 
acos1(x)
Return math.acos(max(-1, min(1, x))).
 
acre2ha(acres)
Convert acres to hectare.
 
acre2m2(acres)
Convert acres to square meter.
 
anStr(name, OKd='._-', sub='_')
DEPRECATED, use function pygeodesy.anstr.
 
anstr(name, OKd='._-', sub='_')
Make a valid name of alphanumeric and OKd characters.
 
antipode(lat, lon)
Return the antipode, the point diametrically opposite to a given point in degrees.
 
antipode_(phi, lam)
Return the antipode, the point diametrically opposite to a given point in radians.
 
areaOf(points, adjust=True, radius=6371008.77141, wrap=True)
Approximate the area of a polygon.
 
areaof(points, adjust=True, radius=6371008.77141, wrap=True)
DEPRECATED, use function pygeodesy.areaOf.
 
asin1(x)
Return math.asin(max(-1, min(1, x))).
 
atan2b(y, x)
Return atan2(y, x) in degrees [0..+360].
 
atan2d(y, x, reverse=False)
Return atan2(y, x) in degrees [-180..+180], optionally reversed (by 180 degrees for azi2).
 
atand(y_x)
Return atan(y_x) angle in degrees.
 
attrs(inst, *names, **Nones_True__pairs_kwds)
Get instance attributes as name=value strings, with floats formatted by function fstr.
 
b_f2a(b, f)
Return a, the equatorial radius for a given polar radius and flattening.
 
b_f_2a(b, f_)
Return a, the equatorial radius for a given polar radius and inverse flattening.
 
bearing(lat1, lon1, lat2, lon2, **options)
Compute the initial or final bearing (forward or reverse azimuth) between a (spherical) start and end point.
 
bearingDMS(bearing, form='d', prec=None, sep='', **s_D_M_S)
Convert bearing to a string (without compass point suffix).
 
bearing_(phi1, lam1, phi2, lam2, final=False, wrap=False)
Compute the initial or final bearing (forward or reverse azimuth) between a (spherical) start and end point.
 
bounds(points, wrap=True, LatLon=None)
DEPRECATED, use function pygeodesy.boundsOf.
 
boundsOf(points, wrap=True, LatLon=None)
Determine the lower-left SW and upper-right NE corners of a path or polygon.
 
callername(up=1, dflt='', source=False, underOK=False)
Get the name of the invoking callable.
 
cassini(pointA, pointB, pointC, alpha, beta, useZ=False, Clas=None, **Clas_kwds)
3-Point resection using Cassini's method.
 
cbrt(x3)
Compute the cube root x3**(1/3).
 
cbrt2(x3)
Compute the cube root squared x3**(2/3).
 
centroidOf(points, wrap=True, LatLon=None)
Determine the centroid of a polygon.
 
chain2m(chains)
Convert UK chains to meter.
 
circin6(point1, point2, point3, eps=8.881784197e-16, useZ=True)
Return the radius and center of the inscribed aka In- circle of a (2- or 3-D) triangle.
 
circle4(earth, lat)
Get the equatorial or a parallel circle of latitude.
 
circum3(point1, point2, point3, circum=True, eps=8.881784197e-16, useZ=True)
Return the radius and center of the smallest circle through or containing three (2- or 3-D) points.
 
circum4_(*points, **Vector_and_kwds)
Best-fit a sphere through three or more (3-D) points.
 
classname(inst, prefixed=None)
Return the instance' class name optionally prefixed with the module name.
 
classnaming(prefixed=None)
Get/set the default class naming for [module.]class names.
 
clipCS3(points, lowerleft, upperright, closed=False, inull=False)
DEPRECATED, use function pygeodesy.clipCS4.
 
clipCS4(points, lowerleft, upperright, closed=False, inull=False)
Clip a path against a rectangular clip box using the Cohen-Sutherland algorithm.
 
clipDMS(deg, limit)
DEPRECATED, use function pygeodesy.clipDegrees.
 
clipDegrees(deg, limit)
Clip a lat- or longitude to the given range.
 
clipLB6(points, lowerleft, upperright, closed=False, inull=False)
Clip a path against a rectangular clip box using the Liang-Barsky algorithm.
 
clipRadians(rad, limit)
Clip a lat- or longitude to the given range.
 
clipSH(points, corners, closed=False, inull=False)
Clip a polygon against a clip region or box using the Sutherland-Hodgman algorithm.
 
clipSH3(points, corners, closed=False, inull=False)
Clip a polygon against a clip region or box using the Sutherland-Hodgman algorithm.
 
clipStr(bstr, limit=50, white='')
DEPRECATED, use function pygeodesy.clips.
 
clips(bstr, limit=50, white='')
Clip a string to the given length limit.
 
collins(pointA, pointB, pointC, alpha, beta, **useZ_Clas_and_kwds)
DEPRECATED, use function pygeodesy.collins5.
 
collins5(pointA, pointB, pointC, alpha, beta, useZ=False, Clas=None, **Clas_kwds)
3-Point resection using Collins' method.
 
compassAngle(lat1, lon1, lat2, lon2, adjust=True, wrap=False)
Return the angle from North for the direction vector (lon2 - lon1, lat2 - lat1) between two points.
 
compassDMS(bearing, form='d', prec=None, sep='', **s_D_M_S)
Convert bearing to a string suffixed with compass point.
 
compassPoint(bearing, prec=3)
Convert bearing to a compass point.
 
copysign0(x, y)
Like math.copysign(x, y) except zero, unsigned.
 
copytype(x, y)
Return the value of x as type of y.
 
cosineAndoyerLambert(lat1, lon1, lat2, lon2, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., wrap=False)
Compute the distance between two (ellipsoidal) points using the Andoyer-Lambert correction of the Law of Cosines fromula.
 
cosineAndoyerLambert_(phi2, phi1, lam21, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...)
Compute the angular distance between two (ellipsoidal) points using the Andoyer-Lambert correction of the Law of Cosines fromula.
 
cosineForsytheAndoyerLambert(lat1, lon1, lat2, lon2, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., wrap=False)
Compute the distance between two (ellipsoidal) points using the Forsythe-Andoyer-Lambert correction of the Law of Cosines formula.
 
cosineForsytheAndoyerLambert_(phi2, phi1, lam21, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...)
Compute the angular distance between two (ellipsoidal) points using the Forsythe-Andoyer-Lambert correction of the Law of Cosines formula.
 
cosineLaw(lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)
Compute the distance between two points using the spherical Law of Cosines formula.
 
cosineLaw_(phi2, phi1, lam21)
Compute the angular distance between two points using the spherical Law of Cosines formula.
 
cot(rad, **error_kwds)
Return the cotangent of an angle in radians.
 
cot_(*rads, **error_kwds)
Return the cotangent of angle(s) in radiansresection.
 
cotd(deg, **error_kwds)
Return the cotangent of an angle in degrees.
 
cotd_(*degs, **error_kwds)
Return the cotangent of angle(s) in degrees.
 
crosserrors(raiser=None)
Report or ignore vectorial cross product errors.
 
date2epoch(year, month, day)
Return the reference frame epoch for a calendar day.
 
decodeEPSG2(arg)
DEPRECATED, use function epsg.decode2.
 
degDMS(deg, prec=6, s_D='°', s_M='\xe2\x80\xb2', s_S='', neg='-', pos='')
Convert degrees to a string in degrees, minutes or seconds.
 
degrees(x)
Convert angle x from radians to degrees.
 
degrees180(rad)
Convert radians to degrees and wrap [-180..+180].
 
degrees2grades(deg)
Convert degrees to grades (aka gons or gradians).
 
degrees2m(deg, radius=6371008.77141, lat=0)
Convert an angle to a distance along the equator or along the parallel at an other (geodetic) latitude.
 
degrees360(rad)
Convert radians to degrees and wrap [0..+360).
 
degrees90(rad)
Convert radians to degrees and wrap [-270..+90].
 
deprecated_Property_RO(method)
Decorator for a DEPRECATED Property_RO.
 
deprecated_class(cls_or_class)
Use inside __new__ or __init__ of a DEPRECATED class.
 
deprecated_function(call)
Decorator for a DEPRECATED function.
 
deprecated_method(call)
Decorator for a DEPRECATED method.
 
deprecated_property_RO(method)
Decorator for a DEPRECATED property_RO.
 
egmGeoidHeights(GeoidHeights_dat)
Generate geoid egm*.pgm height tests from GeoidHeights.dat Test data for Geoids.
 
elevation2(lat, lon, timeout=2.0)
Get the geoid elevation at an NAD83 to NAVD88 location.
 
enStr2(easting, northing, prec, *extras)
DEPRECATED, use function pygeodesy.enstr2.
 
encodeEPSG(zone, hemipole='', band='')
DEPRECATED, use function epsg.encode.
 
enstr2(easting, northing, prec, *extras)
Return easting, northing string representations.
 
epoch2date(epoch)
Return the date for a reference frame epoch.
 
equidistant(lat0, lon0, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., exact=False, geodsolve=False, name='')
Return an EquidistantExact, EquidistantGeodSolve or (if Karney's geographiclib package is installed) an EquidistantKarney, otherwise an Equidistant instance.
 
equirectangular(lat1, lon1, lat2, lon2, radius=6371008.77141, **options)
Compute the distance between two points using the Equirectangular Approximation / Projection.
 
equirectangular3(lat1, lon1, lat2, lon2, **options)
DEPRECATED, use function equirectangular_.
 
equirectangular_(lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap=False)
Compute the distance between two points using the Equirectangular Approximation / Projection.
 
euclid(x, y)
Appoximate the norm sqrt(x**2 + y**2) by max(abs(x), abs(y)) + min(abs(x), abs(y)) * 0.4142....
 
euclid_(*xs)
Appoximate the norm sqrt(sum(x**2 for x in xs)) by cascaded euclid.
 
euclidean(lat1, lon1, lat2, lon2, radius=6371008.77141, adjust=True, wrap=False)
Approximate the Euclidean distance between two (spherical) points.
 
euclidean_(phi2, phi1, lam21, adjust=True)
Approximate the angular Euclidean distance between two (spherical) points.
 
exception_chaining(error=None)
Get the previous exception's or exception chaining setting.
 
excessAbc(A, b, c)
Compute the spherical excess E of a (spherical) triangle from two sides and the included angle.
 
excessGirard(A, B, C)
Compute the spherical excess E of a (spherical) triangle using Girard's formula.
 
excessKarney(lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)
Compute the surface area of a (spherical) quadrilateral bounded by a segment of a great circle, two meridians and the equator using Karney's method.
 
excessKarney_(phi2, phi1, lam21)
Compute the spherical excess E of a (spherical) quadrilateral bounded by a segment of a great circle, two meridians and the equator using Karney's method.
 
excessLHuilier(a, b, c)
Compute the spherical excess E of a (spherical) triangle using L'Huilier's Theorem.
 
excessQuad(lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)
Compute the surface area of a (spherical) quadrilateral bounded by a segment of a great circle, two meridians and the equator.
 
excessQuad_(phi2, phi1, lam21)
Compute the spherical excess E of a (spherical) quadrilateral bounded by a segment of a great circle, two meridians and the equator.
 
f2e2(f)
Return e2, the 1st eccentricity squared for a given flattening.
 
f2e22(f)
Return e22, the 2nd eccentricity squared for a given flattening.
 
f2e32(f)
Return e32, the 3rd eccentricity squared for a given flattening.
 
f2f2(f)
Return f2, the 2nd flattening for a given flattening.
 
f2f_(f)
Return f_, the inverse flattening for a given flattening.
 
f2n(f)
Return n, the 3rd flattening for a given flattening.
 
fStr(floats, prec=6, fmt='f', ints=False, sep=', ')
DEPRECATED, use function fstr.
 
fStrzs(floatstr)
DEPRECATED, use function pygeodesy.fstrzs.
 
f_2f(f_)
Return f, the flattening for a given inverse flattening.
 
facos1(x)
Fast approximation of pygeodesy.acos1(x).
 
false2f(value, name='value', false=True, Error=<type 'exceptions.ValueError'>)
DEPRECATED, use function falsed2f.
 
falsed2f(falsed=True, Error=<type 'exceptions.ValueError'>, **name_value)
DEPRECATED, use class Easting or Northing.
 
fasin1(x)
Fast approximation of pygeodesy.asin1(x).
 
fatan(x)
Fast approximation of atan(x).
 
fatan1(x)
Fast approximation of atan(x) for 0 <= x <= 1, unchecked.
 
fatan2(y, x)
Fast approximation of atan2(y, x).
 
fathom2m(fathoms)
Convert Imperial fathom to meter.
 
favg(v1, v2, f=0.5)
Return the average of two values.
 
fdot(a, *b)
Return the precision dot product sum(a[i] * b[i] for i=0..len(a)).
 
fdot3(a, b, c, start=0)
Return the precision dot product start + sum(a[i] * b[i] * c[i] for i=0..len(a)).
 
fhorner(x, *cs)
Evaluate the polynomial sum(cs[i] * x**i for i=0..len(cs)) using the Horner form.
 
fidw(xs, ds, beta=2)
Interpolate using using Inverse Distance Weighting (IDW).
 
flatLocal(lat1, lon1, lat2, lon2, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., wrap=False)
Compute the distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.
 
flatLocal_(phi2, phi1, lam21, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...)
Compute the angular distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.
 
flatPolar(lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)
Compute the distance between two (spherical) points using the polar coordinate flat-Earth formula.
 
flatPolar_(phi2, phi1, lam21)
Compute the angular distance between two (spherical) points using the polar coordinate flat-Earth formula.
 
float_(*fs)
Yield all positional fs as float.
 
fmean(xs)
Compute the accurate mean sum(xs[i] for i=0..len(xs)) / len(xs).
 
fmean_(*xs)
Compute the accurate mean sum(xs[i] for i=0..len(xs)) / len(xs).
 
fpolynomial(x, *cs)
Evaluate the polynomial sum(cs[i] * x**i for i=0..len(cs)).
 
fpowers(x, n, alts=0)
Return a series of powers [x**i for i=1..n].
 
fprod(xs, start=1.0)
Iterable product, like math.prod or numpy.prod.
 
fractional(points, fi, j=None, wrap=None, LatLon=None, Vector=None, **kwds)
Return the point at a given fractional index.
 
frange(start, number, step=1)
Generate a range of floats.
 
frechet_(points1, points2, distance=None, units='')
Compute the discrete Fréchet distance between two paths given as sets of points.
value
freduce(function, sequence, initial=...)
Apply a function of two arguments cumulatively to the items of a sequence, from left to right, so as to reduce the sequence to a single value.
 
fremainder(x, y)
Remainder in range [-y / 2, y / 2].
 
fstr(floats, prec=6, fmt='F', ints=False, sep=', ', strepr=None)
Convert one or more floats to string, optionally stripped of trailing zero decimals.
 
fstrzs(efstr, ap1z=False)
Strip trailing zero decimals from a float string.
 
fsum(xs)
Precision floating point summation based on or like Python's math.fsum.
 
fsum1(xs)
Precision floating point summation of a few values, 1-primed.
 
fsum1_(*xs)
Precision floating point summation of a few arguments, 1-primed.
 
fsum_(*xs)
Precision floating point summation of all positional arguments.
 
ft2m(feet, usurvey=False, pied=False)
Convert International, US Survey or French feet to meter.
 
furlong2m(furlongs)
Convert a furlong to meter.
 
geoidHeight2(lat, lon, model=0, timeout=2.0)
Get the NAVD88 geoid height at an NAD83 location.
 
gnomonic(lat0, lon0, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., exact=False, geodsolve=False, name='')
Return a GnomonicExact or (if Karney's geographiclib package is installed) a GnomonicKarney, otherwise a Gnomonic instance.
 
grades(rad)
Convert radians to grades (aka gons or gradians).
 
grades2degrees(gon)
Convert grades (aka gons or gradians) to degrees.
 
grades2radians(gon)
Convert grades (aka gons or gradians) to radians.
 
grades400(rad)
Convert radians to grades (aka gons or gradians) and wrap [0..+400).
 
halfs2(str2)
Split a string in 2 halfs.
 
hartzell(pov, los=None, earth=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., **LatLon_and_kwds)
Compute the intersection of a Line-Of-Sight from a Point-Of-View in space with the surface of the earth.
 
hausdorff_(model, target, both=False, early=True, seed=None, units='', distance=None, point=<function _point at 0x7fd000186450>)
Compute the directed or symmetric Hausdorff distance between 2 sets of points with or without early breaking and random sampling.
 
haversine(lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)
Compute the distance between two (spherical) points using the Haversine formula.
 
haversine_(phi2, phi1, lam21)
Compute the angular distance between two (spherical) points using the Haversine formula.
 
heightOf(angle, distance, radius=6371008.77141)
Determine the height above the (spherical) earth' surface after traveling along a straight line at a given tilt.
 
horizon(height, radius=6371008.77141, refraction=False)
Determine the distance to the horizon from a given altitude above the (spherical) earth.
 
hstr(height, prec=2, fmt='%+.*f', ints=False, m='')
Return a string for the height value.
 
hubeny(lat1, lon1, lat2, lon2, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., wrap=False)
Compute the distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.
 
hubeny_(phi2, phi1, lam21, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...)
Compute the angular distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.
 
hypot(x, y)
Return the Euclidean distance, sqrt(x*x + y*y).
 
hypot1(x)
Compute the norm sqrt(1 + x**2).
 
hypot2(x, y)
Compute the squared norm x**2 + y**2.
 
hypot2_(*xs)
Compute the squared norm sum(x**2 for x in xs).
 
hypot3(x, y, z)
DEPRECATED, use function pygeodesy.hypot_.
 
hypot_(*xs)
Compute the norm sqrt(sum(x**2 for x in xs)).
 
inStr(inst, *args, **kwds)
DEPRECATED, use function pygeodesy.instr.
 
instr(inst, *args, **kwds)
Return the string representation of an instantiation.
 
intersection3d3(start1, end1, start2, end2, eps=2.22044604925e-16, useZ=True, **Vector_and_kwds)
Compute the intersection point of two lines, each defined by or through a start and end point (3-D).
 
intersections2(center1, radius1, center2, radius2, sphere=True, **Vector_and_kwds)
Compute the intersection of two spheres or circles, each defined by a (3-D) center point and a radius.
 
isNumpy2(obj)
Check for an Numpy2LatLon points wrapper.
 
isPoints2(obj)
Check for an LatLon2psxy points wrapper.
 
isTuple2(obj)
Check for an Tuple2LatLon points wrapper.
 
isantipode(lat1, lon1, lat2, lon2, eps=2.22044604925e-16)
Check whether two points are antipodal, on diametrically opposite sides of the earth.
 
isantipode_(phi1, lam1, phi2, lam2, eps=2.22044604925e-16)
Check whether two points are antipodal, on diametrically opposite sides of the earth.
 
isbool(obj)
Check whether an object is boolean.
 
isclass(obj)
Return True if obj is a class.
 
isclockwise(points, adjust=False, wrap=True)
Determine the direction of a path or polygon.
 
iscolinearWith(point, point1, point2, eps=2.22044604925e-16, useZ=True)
Check whether a point is colinear with two other (2- or 3-D) points.
 
iscomplex(obj)
Check whether an object is complex.
 
isconvex(points, adjust=False, wrap=True)
Determine whether a polygon is convex.
 
isconvex_(points, adjust=False, wrap=True)
Determine whether a polygon is convex and clockwise.
 
isenclosedBy(point, points, wrap=False)
Determine whether a point is enclosed by a polygon.
 
isenclosedby(point, points, wrap=False)
DEPRECATED, use function pygeodesy.isenclosedBy.
 
isfinite(obj)
Check for non-finite scalar value.
 
isidentifier(obj)
Return True if obj is a valid Python identifier.
bool
isinf(x)
Check if float x is infinite (positive or negative).
 
isint(obj, both=False)
Check for int type or an integer float value.
 
isint0(obj, both=False)
Check for INT0 or int(0) value.
 
iskeyword(x, y)
y in x.
bool
isnan(x)
Check if float x is not a number (NaN).
 
isnear0(x, eps0=4.93038065763e-32)
Is x near zero?
 
isnear1(x, eps0=4.93038065763e-32)
Is x near one?
 
isneg0(x)
Check for NEG0, negative 0.0.
 
isninf(x)
Check for NINF, negative INF.
 
isnon0(x, eps0=4.93038065763e-32)
Is x non-zero?
 
isodd(x)
Is x odd?
 
ispolar(points, wrap=False)
Check whether a polygon encloses a pole.
 
isscalar(obj)
Check for scalar types.
 
issequence(obj, *excls)
Check for sequence types.
 
isstr(obj)
Check for string types.
 
issubclassof(Sub, *Supers)
Check whether a class is a sub-class of some other class(es).
 
iterNumpy2(obj)
Iterate over Numpy2 wrappers or other sequences exceeding the threshold.
 
iterNumpy2over(n=None)
Get or set the iterNumpy2 threshold.
 
joined(*words, **sep)
DEPRECATED, use NN(...), NN.join_ or sep.join.
 
joined_(*words, **sep)
DEPRECATED, use _SPACE_(...), _SPACE_.join_ or sep.join, sep=" ".
 
latDMS(deg, form='dms', prec=2, sep='', **s_D_M_S)
Convert latitude to a string, optionally suffixed with N or S.
 
latlon2n_xyz(lat, lon, name='')
Convert lat-, longitude to n-vector (normal to the earth's surface) X, Y and Z components.
 
latlonDMS(lls, form='dms', prec=None, sep=None, **s_D_M_S)
Convert one or more LatLon instances to strings.
 
latlonDMS_(*lls, **form_prec_sep_s_D_M_S)
Convert one or more LatLon instances to strings.
 
len2(items)
Make built-in function len work for generators, iterators, etc.
 
limiterrors(raiser=None)
Get/set the throwing of LimitErrors.
 
lonDMS(deg, form='dms', prec=2, sep='', **s_D_M_S)
Convert longitude to a string, optionally suffixed with E or W.
 
luneOf(lon1, lon2, closed=False, LatLon=<class 'pygeodesy.points.LatLon_'>, **LatLon_kwds)
Generate an ellipsoidal or spherical lune-shaped path or polygon.
 
m2NM(meter)
Convert meter to nautical miles (NM).
 
m2SM(meter)
Convert meter to statute miles (SM).
 
m2chain(meter)
Convert meter to UK chains.
 
m2degrees(distance, radius=6371008.77141, lat=0)
Convert a distance to an angle along the equator or along the parallel at an other (geodetic) latitude.
 
m2fathom(meter)
Convert meter to Imperial fathoms.
 
m2ft(meter, usurvey=False, pied=False)
Convert meter to International, US Survey or French feet (ft).
 
m2furlong(meter)
Convert meter to furlongs.
 
m2km(meter)
Convert meter to kilo meter (km).
 
m2radians(distance, radius=6371008.77141, lat=0)
Convert a distance to an angle along the equator or along the parallel at an other (geodetic) latitude.
 
m2toise(meter)
Convert meter to French toises.
 
m2yard(meter)
Convert meter to UK yards.
 
machine()
Return standard platform.machine, but distinguishing Intel from Intel emulation on Apple Silicon (on macOS only).
 
map1(fun1, *xs)
Apply each argument to a single-argument function and return a tuple of results.
 
map2(func, *xs)
Apply arguments to a function and return a tuple of results.
 
meeus2(point1, point2, point3, circum=False, useZ=True)
Return the radius and Meeus' Type of the smallest circle through or containing three (2- or 3-D) points.
 
modulename(clas, prefixed=None)
Return the class name optionally prefixed with the module name.
 
n2e2(n)
Return e2, the 1st eccentricity squared for a given 3rd flattening.
 
n2f(n)
Return f, the flattening for a given 3rd flattening.
 
n2f_(n)
Return f_, the inverse flattening for a given 3rd flattening.
 
n_xyz2latlon(x, y, z, name='')
Convert n-vector components to lat- and longitude in degrees.
 
n_xyz2philam(x, y, z, name='')
Convert n-vector components to lat- and longitude in radians.
 
nameof(inst)
Get the name of an instance.
 
nearestOn(point, point1, point2, within=True, useZ=True, Vector=None, **Vector_kwds)
Locate the point between two points closest to a reference (2- or 3-D).
 
nearestOn3(point, points, closed=False, wrap=False, **options)
DEPRECATED, use function pygeodesy.nearestOn5.
 
nearestOn4(point, points, closed=False, wrap=False, **options)
DEPRECATED, use function pygeodesy.nearestOn5.
 
nearestOn5(point, points, closed=False, wrap=False, LatLon=None, **options)
Locate the point on a path or polygon closest to a reference point.
 
nearestOn6(point, points, closed=False, useZ=True, **Vector_and_kwds)
Locate the point on a path or polygon closest to a reference point.
 
neg(x)
Negate x unless zero or NEG0.
 
neg_(*xs)
Negate all of xs with neg.
 
norm2(x, y)
Normalize a 2-dimensional vector.
 
normDMS(strDMS, norm=None, **s_D_M_S)
Normalize all degrees, minutes and seconds (DMS) symbols in a string to the default symbols S_DEG, S_MIN, S_SEC.
 
norm_(*xs)
Normalize all n-dimensional vector components.
 
notImplemented(inst, *args, **kwds)
Raise a NotImplementedError for a missing method or property.
 
notOverloaded(inst, *args, **kwds)
Raise an AssertionError for a method or property not overloaded.
 
opposing(bearing1, bearing2, margin=None)
Compare the direction of two bearings given in degrees.
 
opposing_(radians1, radians2, margin=None)
Compare the direction of two bearings given in radians.
 
pairs(items, prec=6, fmt='F', ints=False, sep='=')
Convert items to name=value strings, with floats handled like fstr.
 
parse3d(str3d, sep=',', Vector=<class 'pygeodesy.vector3d.Vector3d'>, **Vector_kwds)
Parse an "x, y, z" string.
 
parse3llh(strllh, height=0, sep=',', clipLat=90, clipLon=180, **s_D_M_S)
Parse a string "lat lon [h]" representing lat-, longitude in degrees and optional height in meter.
 
parseDDDMMSS(strDDDMMSS, suffix='NSEW', sep='', clip=0, sexagecimal=False)
Parse a lat- or longitude represention forms as [D]DDMMSS in degrees.
 
parseDMS(strDMS, suffix='NSEW', sep='', clip=0, **s_D_M_S)
Parse a lat- or longitude representation in degrees.
 
parseDMS2(strLat, strLon, sep='', clipLat=90, clipLon=180, **s_D_M_S)
Parse a lat- and a longitude representions "lat, lon" in degrees.
 
parseETM5(strUTM, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Etm=<class 'pygeodesy.etm.Etm'>, falsed=True, name='')
Parse a string representing a UTM coordinate, consisting of "zone[band] hemisphere easting northing".
 
parseMGRS(strMGRS, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Mgrs=<class 'pygeodesy.mgrs.Mgrs'>, name='')
Parse a string representing a MGRS grid reference, consisting of "zoneBand, grid, easting, northing".
 
parseOSGR(strOSGR, Osgr=<class 'pygeodesy.osgr.Osgr'>, name='')
Parse a string representing an OSGR grid reference, consisting of "[grid] easting northing".
 
parseRad(strRad, suffix='NSEW', clip=0)
Parse a string representing angle in radians.
 
parseUPS5(strUPS, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Ups=<class 'pygeodesy.ups.Ups'>, falsed=True, name='')
Parse a string representing a UPS coordinate, consisting of "[zone][band] pole easting northing" where zone is pseudo zone "00"|"0"|"" and band is 'A'|'B'|'Y'|'Z'|''.
 
parseUTM(strUTM, datum=_UTM, Utm=_UTM, name='')
DEPRECATED, use function parseUTM5.
 
parseUTM5(strUTM, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Utm=<class 'pygeodesy.utm.Utm'>, falsed=True, name='')
Parse a string representing a UTM coordinate, consisting of "zone[band] hemisphere easting northing".
 
parseUTMUPS5(strUTMUPS, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Utm=<class 'pygeodesy.utm.Utm'>, Ups=<class 'pygeodesy.ups.Ups'>, name='')
Parse a string representing a UTM or UPS coordinate, consisting of "zone[band] hemisphere/pole easting northing".
 
parseWM(strWM, radius=6378137.0, Wm=<class 'pygeodesy.webmercator.Wm'>, name='')
Parse a string "e n [r]" representing a WM coordinate, consisting of easting, northing and an optional radius.
 
perimeterOf(points, closed=False, adjust=True, radius=6371008.77141, wrap=True)
Approximate the perimeter of a path or polygon.
 
perimeterof(points, closed=False, adjust=True, radius=6371008.77141, wrap=True)
DEPRECATED, use function perimeterOf.
 
philam2n_xyz(phi, lam, name='')
Convert lat-, longitude to n-vector (normal to the earth's surface) X, Y and Z components.
 
pierlot(point1, point2, point3, alpha12, alpha23, useZ=False, Clas=None, **Clas_kwds)
3-Point resection using Pierlot's method ToTal.
 
points2(points, closed=True, base=None, Error=<class 'pygeodesy.errors.PointsError'>)
Check a path or polygon represented by points.
 
polygon(points, closed=True, base=None)
DEPRECATED, use function points2.
 
precision(form, prec=None)
Set the default precison for a given F_ form.
 
print_(*args, **nl_nt_prefix_end_file_flush_sep)
Python 3-style print function.
 
printf(fmt, *args, **nl_nt_prefix_end_file_flush_sep)
C-style printf function.
 
property_doc_(doc)
Decorator for a standard property with basic documentation.
 
quadOf(latS, lonW, latN, lonE, closed=False, LatLon=<class 'pygeodesy.points.LatLon_'>, **LatLon_kwds)
Generate a quadrilateral path or polygon from two points.
 
radians(x)
Convert angle x from degrees to radians.
 
radians2m(rad, radius=6371008.77141, lat=0)
Convert an angle to a distance along the equator or along the parallel at an other (geodetic) latitude.
 
radiansPI(deg)
Convert and wrap degrees to radians [-PI..+PI].
 
radiansPI2(deg)
Convert and wrap degrees to radians [0..+2PI).
 
radiansPI_2(deg)
Convert and wrap degrees to radians [-3PI/2..+PI/2].
 
radical2(distance, radius1, radius2)
Compute the radical ratio and radical line of two intersecting circles.
 
radii11(point1, point2, point3, useZ=True)
Return the radii of the In-, Soddy and Tangent circles of a (2- or 3-D) triangle.
 
randomrangenerator(seed)
Return a seeded random range function generator.
 
rangerrors(raiser=None)
Get/set the throwing of RangeErrors.
 
remainder(x, y)
Mimick Python 3.7+ math.remainder.
 
reprs(objs, prec=6, fmt='F', ints=False)
Convert objects to repr strings, with floats handled like fstr.
 
scalar(value, low=2.22044604925e-16, high=1.0, name='scalar', Error=<type 'exceptions.ValueError'>)
DEPRECATED, use class Number_ or Scalar_.
 
signOf(x)
Return sign of x as int.
 
simplify1(points, distance=0.001, radius=6371008.77141, indices=False, **options)
Basic simplification of a path of LatLon points.
 
simplify2(points, pipe, radius=6371008.77141, shortest=False, indices=False, **options)
DEPRECATED, use function pygeodesy.simplifyRW.
 
simplifyRDP(points, distance=0.001, radius=6371008.77141, shortest=False, indices=False, **options)
Ramer-Douglas-Peucker (RDP) simplification of a path of LatLon points.
 
simplifyRDPm(points, distance=0.001, radius=6371008.77141, shortest=False, indices=False, **options)
Modified Ramer-Douglas-Peucker (RDPm) simplification of a path of LatLon points.
 
simplifyRW(points, pipe=0.001, radius=6371008.77141, shortest=False, indices=False, **options)
Reumann-Witkam (RW) simplification of a path of LatLon points.
 
simplifyVW(points, area=0.001, radius=6371008.77141, attr=None, indices=False, **options)
Visvalingam-Whyatt (VW) simplification of a path of LatLon points.
 
simplifyVWm(points, area=0.001, radius=6371008.77141, attr=None, indices=False, **options)
Modified Visvalingam-Whyatt (VWm) simplification of a path of LatLon points.
 
sincos2(rad)
Return the sine and cosine of an angle in radians.
 
sincos2_(*rads)
Return the sine and cosine of angle(s) in radians.
 
sincos2d(deg, **adeg)
Return the sine and cosine of an angle in degrees.
 
sincos2d_(*degs)
Return the sine and cosine of angle(s) in degrees.
 
snellius3(a, b, degC, alpha, beta)
Snellius' surveying using Snellius Pothenot.
 
soddy4(point1, point2, point3, eps=8.881784197e-16, useZ=True)
Return the radius and center of the inner Soddy circle of a (2- or 3-D) triangle.
 
splice(iterable, n=2, **fill)
Split an iterable into n slices.
 
sqrt0(x2)
Compute the square root iff x2 > EPS02.
 
sqrt3(x2)
Compute the square root, cubed sqrt(x2)**3 or sqrt(x2**3).
 
sqrt_a(h, b)
Compute a side of a right-angled triangle from sqrt(h**2 - b**2).
 
strs(objs, prec=6, fmt='F', ints=False)
Convert objects to str strings, with floats handled like fstr.
 
tanPI_2_2(rad)
Compute the tangent of half angle, 90 degrees rotated.
 
tan_2(rad, **semi)
Compute the tangent of half angle.
 
tand(deg, **error_kwds)
Return the tangent of an angle in degrees.
 
tand_(*degs, **error_kwds)
Return the tangent of angle(s) in degrees.
 
thomas(lat1, lon1, lat2, lon2, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., wrap=False)
Compute the distance between two (ellipsoidal) points using Thomas' formula.
 
thomas_(phi2, phi1, lam21, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...)
Compute the angular distance between two (ellipsoidal) points using Thomas' formula.
 
tienstra(pointA, pointB, pointC, alpha, **beta_gamma_useZ_Clas_and_kwds)
DEPRECATED, use function pygeodesy.tienstra7.
 
tienstra7(pointA, pointB, pointC, alpha, beta=None, gamma=None, useZ=False, Clas=None, **Clas_kwds)
3-Point resection using Tienstra's formula.
 
toCss(latlon, cs0=None, height=None, Css=<class 'pygeodesy.css.Css'>, name='')
Convert an (ellipsoidal) geodetic point to a Cassini-Soldner location.
 
toDMS(deg, form='dms', prec=2, sep='', ddd=2, neg='-', pos='+', **s_D_M_S)
Convert signed degrees to string, without suffix.
 
toEtm8(latlon, lon=None, datum=None, Etm=<class 'pygeodesy.etm.Etm'>, falsed=True, name='', zone=None, **cmoff)
Convert a lat-/longitude point to an ETM coordinate.
 
toLcc(latlon, conic=Conic(name='WRF_Lb', lat0=40, lon0=-97, par1=33, par2=45, E0=0..., height=None, Lcc=<class 'pygeodesy.lcc.Lcc'>, name='', **Lcc_kwds)
Convert an (ellipsoidal) geodetic point to a Lambert location.
 
toMgrs(utm, Mgrs=<class 'pygeodesy.mgrs.Mgrs'>, name='', **Mgrs_kwds)
Convert a UTM coordinate to an MGRS grid reference.
 
toOsgr(latlon, lon=None, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Osgr=<class 'pygeodesy.osgr.Osgr'>, name='', **Osgr_kwds)
Convert a lat-/longitude point to an OSGR coordinate.
 
toUps8(latlon, lon=None, datum=None, Ups=<class 'pygeodesy.ups.Ups'>, pole='', falsed=True, strict=True, name='')
Convert a lat-/longitude point to a UPS coordinate.
 
toUtm(latlon, lon=None, datum=None, Utm=_UTM, cmoff=True, name='')
DEPRECATED, use function pygeodesy.toUtm8.
 
toUtm8(latlon, lon=None, datum=None, Utm=<class 'pygeodesy.utm.Utm'>, falsed=True, name='', zone=None, **cmoff)
Convert a lat-/longitude point to a UTM coordinate.
 
toUtmUps8(latlon, lon=None, datum=None, falsed=True, Utm=<class 'pygeodesy.utm.Utm'>, Ups=<class 'pygeodesy.ups.Ups'>, pole='', name='', **cmoff)
Convert a lat-/longitude point to a UTM or UPS coordinate.
 
toWm(latlon, lon=None, radius=6378137.0, Wm=<class 'pygeodesy.webmercator.Wm'>, name='', **Wm_kwds)
Convert a lat-/longitude point to a WM coordinate.
 
toise2m(toises)
Convert French toises to meter.
 
trfXform(reframe1, reframe2, epoch=None, xform=None, rates=None)
Define a new Terrestrial Reference Frame (TRF) conversion.
 
triAngle(a, b, c)
Compute one angle of a triangle.
 
triAngle4(a, b, c)
Compute the angles of a triangle.
 
triSide(a, b, radC)
Compute one side of a triangle.
 
triSide2(b, c, radB)
Compute one side and the opposite angle of a triangle.
 
triSide4(radA, radB, c)
Compute two sides and the height of a triangle.
 
trilaterate2d2(x1, y1, radius1, x2, y2, radius2, x3, y3, radius3, eps=None, **Vector_and_kwds)
Trilaterate three circles, each given as a (2-D) center and a radius.
 
trilaterate3d2(center1, radius1, center2, radius2, center3, radius3, eps=2.22044604925e-16, **Vector_and_kwds)
Trilaterate three spheres, each given as a (3-D) center and a radius.
 
tyr3d(tilt=0, yaw=0, roll=0, Vector=<class 'pygeodesy.vector3d.Vector3d'>, **Vector_kwds)
Convert an attitude oriention into a (3-D) direction vector.
 
ub2str(ub)
Convert unicode or bytes to str.
 
unStr(name, *args, **kwds)
DEPRECATED, use function pygeodesy.unstr.
 
unroll180(lon1, lon2, wrap=True)
Unroll longitudinal delta and wrap longitude in degrees.
 
unrollPI(rad1, rad2, wrap=True)
Unroll longitudinal delta and wrap longitude in radians.
 
unsign0(x)
DEPRECATED, use function pygeodesy.unsigned0.
 
unsigned0(x)
Return 0.0 unsigned.
 
unstr(named, *args, **kwds)
Return the string representation of an invokation.
 
upsZoneBand5(lat, lon, strict=True, name='')
Return the UTM/UPS zone number, polar Band letter, pole and clipped lat- and longitude for a given location.
 
utmZoneBand2(lat, lon)
DEPRECATED, use function pygeodesy.utmZoneBand5.
 
utmZoneBand5(lat, lon, cmoff=False, name='')
Return the UTM zone number, Band letter, hemisphere and (clipped) lat- and longitude for a given location.
 
utmupsValidate(coord, falsed=False, MGRS=False, Error=<class 'pygeodesy.utmups.UTMUPSError'>)
Check a UTM or UPS coordinate.
 
utmupsValidateOK(coord, falsed=False, ok=True)
Check a UTM or UPS coordinate.
 
utmupsZoneBand5(lat, lon, cmoff=False, name='')
Return the UTM/UPS zone number, Band letter, hemisphere/pole and clipped lat- and longitude for a given location.
 
vincentys(lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)
Compute the distance between two (spherical) points using Vincenty's spherical formula.
 
vincentys_(phi2, phi1, lam21)
Compute the angular distance between two (spherical) points using Vincenty's spherical formula.
 
wildberger3(a, b, c, alpha, beta, R3=<built-in function min>)
Snellius' surveying using Rational Trigonometry.
 
wrap180(deg)
Wrap degrees to [-180..+180].
 
wrap360(deg)
Wrap degrees to [0..+360).
 
wrap90(deg)
Wrap degrees to [-270..+90].
 
wrapPI(rad)
Wrap radians to [-PI..+PI].
 
wrapPI2(rad)
Wrap radians to [0..+2PI).
 
wrapPI_2(rad)
Wrap radians to [-3PI/2..+PI/2].
 
yard2m(yards)
Convert UK yards to meter.
Variables
  pygeodesy_abspath = '..../PyGe...
Fully qualified pygeodesy directory name (str).
  version = '22.5.5'
Normalized PyGeodesy version (str).
  Caps = Caps()
  Conics = Conics.WRF_Lb: Conic(name='WRF_Lb', lat0=40, lon0=-97...
Registered, predefined conics (enum-like).
  DIG = 15
System's float decimal digits = 15 (int).
  Datums = Datums.OSGB36: Datum(name='OSGB36', ellipsoid=Ellipso...
Registered, predefined datums (enum-like).
  EPS = 2.22044604925e-16
System's epsilon ≈ 2.22044604925e-16 (float).
  EPS0 = 4.93038065763e-32
EPS**2 ≈ 4.9e-32 for near-zero comparison
  EPS02 = 2.43086534291e-63
EPS**4 ≈ 2.4e-63 for near-zero squared comparison
  EPS1 = 1.0
1 - EPS ≈ 0.9999999999999998 (float).
  EPS1_2 = 1.0
1 - EPS_2 DEPRECATED, do not use.
  EPS2 = 4.4408920985e-16
EPS * 2 ≈ 4.440892098501e-16 (float).
  EPS4 = 8.881784197e-16
EPS * 4 ≈ 8.881784197001e-16 (float).
  EPS_2 = 1.11022302463e-16
EPS / 2 ≈ 1.110223024625e-16 (float).
  Ellipsoids = Ellipsoids.Airy1830: Ellipsoid(name='Airy1830', a...
Registered, predefined ellipsoids (enum-like).
  F_D = 'd'
Format degrees as unsigned "deg°" with symbol, plus compass point suffix N, S, E or W (str).
  F_D60 = 'd60'
Format degrees as unsigned "[D]DD.MMSS" sexagecimal without symbols, plus suffix (str).
  F_D60_ = '-d60'
Format degrees as signed "-/[D]DD.MMSS" sexagecimal without symbols, without suffix (str).
  F_D60__ = '+d60'
Format degrees as signed "-/+[D]DD.MMSS" sexagecimal without symbols, without suffix (str).
  F_DEG = 'deg'
Format degrees as unsigned "[D]DD" without symbol, plus suffix (str).
  F_DEG_ = '-deg'
Format degrees as signed "-/[D]DD" without symbol, without suffix (str).
  F_DEG__ = '+deg'
Format degrees as signed "-/+[D]DD" without symbol, without suffix (str).
  F_DM = 'dm'
Format degrees as unsigned "deg°min′" with symbols, plus suffix (str).
  F_DMS = 'dms'
Format degrees as unsigned "deg°min′sec″" with symbols, plus suffix (str).
  F_DMS_ = '-dms'
Format degrees as signed "-/deg°min′sec″" with symbols, without suffix (str).
  F_DMS__ = '+dms'
Format degrees as signed "-/+deg°min′sec″" with symbols, without suffix (str).
  F_DM_ = '-dm'
Format degrees as signed "-/deg°min′" with symbols, without suffix (str).
  F_DM__ = '+dm'
Format degrees as signed "-/+deg°min′" with symbols, without suffix (str).
  F_D_ = '-d'
Format degrees as signed "-/deg°" with symbol, without suffix (str).
  F_D__ = '+d'
Format degrees as signed "-/+deg°" with symbol, without suffix (str).
  F_MIN = 'min'
Format degrees as unsigned "[D]DDMM" without symbols, plus suffix (str).
  F_MIN_ = '-min'
Format degrees as signed "-/[D]DDMM" without symbols, without suffix (str).
  F_MIN__ = '+min'
Format degrees as signed "-/+[D]DDMM" without symbols, without suffix (str).
  F_RAD = 'rad'
Convert degrees to radians and format as unsigned "RR" with symbol, plus suffix (str).
  F_RAD_ = '-rad'
Convert degrees to radians and format as signed "-/RR" without symbol, without suffix (str).
  F_RAD__ = '+rad'
Convert degrees to radians and format as signed "-/+RR" without symbol, without suffix (str).
  F_SEC = 'sec'
Format degrees as unsigned "[D]DDMMSS" without symbols, plus suffix (str).
  F_SEC_ = '-sec'
Format degrees as signed "-/[D]DDMMSS" without symbols, without suffix (str).
  F_SEC__ = '+sec'
Format degrees as signed "-/+[D]DDMMSS" without symbols, without suffix (str).
  F__E = 'e'
Format degrees as unsigned "%E" without symbols, plus suffix (str).
  F__E_ = '-e'
Format degrees as signed "-/%E" without symbols, without suffix (str).
  F__E__ = '+e'
Format degrees as signed "-/+%E" without symbols, without suffix (str).
  F__F = 'f'
Format degrees as unsigned "%F" without symbols, plus suffix (str).
  F__F_ = '-f'
Format degrees as signed "-/%F" without symbols, without suffix (str).
  F__F__ = '+f'
Format degrees as signed "-/+%F" without symbols, without suffix (str).
  F__G = 'g'
Format degrees as unsigned "%G" without symbols, plus suffix (str).
  F__G_ = '-g'
Format degrees as signed "-/%G" without symbols, without suffix (str).
  F__G__ = '+g'
Format degrees as signed "-/+%G" without symbols, without suffix (str).
  INF = inf
Infinity (float), see NINF and functions pygeodesy.isinf, pygeodesy.isfinite.
  INT0 = 0
int(0), missing Z-components, if z is INT0, see functions pygeodesy.isint0, pygeodesy.meeus2
  MANTIS = 53
DEPRECATED, use MANT_DIG.
  MANT_DIG = 53
System's float mantissa bits = 53 (int).
  MAX = 1.79769313486e+308
System's float max ≈ 1.798e+308 (float).
  MIN = 2.22507385851e-308
System's float min ≈ 2.225e-308 (float).
  NAN = nan
Not-A-Number (float), see function pygeodesy.isnan.
  NEG0 = -0.0
Negative 0.0 (float), see function pygeodesy.isneg0.
  NINF = -inf
Negative infinity (float), see INF.
  NN = ''
Empty (str), Nomen Nescio.
  OK = 'OK'
DEPRECATED, do not use.
  PI = 3.14159265359
Constant math.pi (float).
  PI2 = 6.28318530718
Two PI, PI * 2, aka Tau (float).
  PI3 = 9.42477796077
Three PI, PI * 3 (float).
  PI3_2 = 4.71238898038
One and a half PI, PI * 3 / 2 (float).
  PI4 = 12.5663706144
Four PI, PI * 4 (float).
  PI_2 = 1.57079632679
Half PI, PI / 2 (float).
  PI_4 = 0.785398163397
Quarter PI, PI / 4 (float).
  R_FM = 6371000.0
Former FAI-Sphere earth radius (meter).
  R_GM = 6371230.0
Average earth radius, distance to geoid surface (meter)
  R_KM = 6371.008771415
Mean (spherical) earth radius (km, kilometer).
  R_M = 6371008.771415
Mean (spherical) earth radius (meter).
  R_MA = 6378137.0
Equatorial earth radius (meter), WGS84, EPSG:3785.
  R_MB = 6356752.3
Polar earth radius (meter), WGS84, EPSG:3785.
  R_NM = 3440.06953100162
Mean (spherical) earth radius (NM, nautical miles).
  R_SM = 3958.7613160486508
Mean (spherical) earth radius (SM, statute miles).
  R_VM = 6366707.0194937
Aviation/Navigation earth radius (meter).
  RefFrames =
Registered, predefined reference frames (enum-like).
  S_DEG = '°'
Degrees symbol, default "°"
  S_MIN = '\xe2\x80\xb2'
Minutes symbol, default "′" aka PRIME
  S_RAD = ''
Radians symbol, default "" aka NN
  S_SEC = ''
Seconds symbol, default "″" aka DOUBLE_PRIME
  S_SEP = ''
Separator between deg°|min′|sec″|suffix, default "" aka NN
  Transforms = Transforms.OSGB36: Transform(name='OSGB36', tx=-4...
Registered, predefined transforms (enum-like).
  isLazy = None
Lazy import setting (int 0, 1, 2 or 3+) from env variable PYGEODESY_LAZY_IMPORT, or None if lazy import is not supported or not enabled, or False if initializing lazy import failed.
Function Details

DeprecationWarnings()

 

Have any DeprecationWarnings been reported or raised?

Returns:
The number of DeprecationWarnings (int) so far or None if not enabled.

Note: To get DeprecationWarnings if any, run python with env var PYGEODESY_WARNINGS set to a non-empty string AND use python[3] command line option -X dev, -W always or -W error, etc.

UtmUps (zone, hemipole, easting, northing, band='', datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., falsed=True, name='')

 

Class-like function to create a UTM/UPS coordinate.

Arguments:
  • zone - The UTM zone with/-out longitudinal Band or UPS zone 0 or "00" with/-out polar Band (str or int).
  • hemipole - UTM hemisphere or UPS top/center of projection (str, 'N[orth]' or 'S[outh]').
  • easting - Easting, see falsed (meter).
  • northing - Northing, see falsed (meter).
  • band - Optional, UTM latitudinal 'C'|'D'|..|'W'|'X' or UPS polar Band letter 'A'|'B'|'Y'|'Z' Band letter (str).
  • datum - Optional, the coordinate's datum (Datum).
  • falsed - Both easting and northing are falsed (bool).
  • name - Optional name (str).
Returns:
New UTM or UPS instance (Utm or Ups).
Raises:
  • TypeError - Invalid datum.
  • UTMUPSError - UTM or UPS validation failed.

See Also: Classes Utm and Ups and Karney's UTMUPS.

a_b2e (a, b)

 

Return e, the 1st eccentricity for a given equatorial and polar radius.

Arguments:
  • a - Equatorial radius (scalar > 0).
  • b - Polar radius (scalar > 0).
Returns:
The unsigned, (1st) eccentricity (float or 0), sqrt(1 - (b / a)**2).

Note: The result is always non-negative and 0 for near-spherical ellipsoids.

a_b2e2 (a, b)

 

Return e2, the 1st eccentricity squared for a given equatorial and polar radius.

Arguments:
  • a - Equatorial radius (scalar > 0).
  • b - Polar radius (scalar > 0).
Returns:
The signed, (1st) eccentricity squared (float or 0), 1 - (b / a)**2.

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

a_b2e22 (a, b)

 

Return e22, the 2nd eccentricity squared for a given equatorial and polar radius.

Arguments:
  • a - Equatorial radius (scalar > 0).
  • b - Polar radius (scalar > 0).
Returns:
The signed, 2nd eccentricity squared (float or 0), (a / b)**2 - 1.

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

a_b2e32 (a, b)

 

Return e32, the 3rd eccentricity squared for a given equatorial and polar radius.

Arguments:
  • a - Equatorial radius (scalar > 0).
  • b - Polar radius (scalar > 0).
Returns:
The signed, 3rd eccentricity squared (float or 0), (a**2 - b**2) / (a**2 + b**2).

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

a_b2f (a, b)

 

Return f, the flattening for a given equatorial and polar radius.

Arguments:
  • a - Equatorial radius (scalar > 0).
  • b - Polar radius (scalar > 0).
Returns:
The flattening (float or 0), (a - b) / a.

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

a_b2f2 (a, b)

 

Return f2, the 2nd flattening for a given equatorial and polar radius.

Arguments:
  • a - Equatorial radius (scalar > 0).
  • b - Polar radius (scalar > 0).
Returns:
The signed, 2nd flattening (float or 0), (a - b) / b.

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

a_b2f_ (a, b)

 

Return f_, the inverse flattening for a given equatorial and polar radius.

Arguments:
  • a - Equatorial radius (scalar > 0).
  • b - Polar radius (scalar > 0).
Returns:
The inverse flattening (float or 0), a / (a - b).

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

a_b2n (a, b)

 

Return n, the 3rd flattening for a given equatorial and polar radius.

Arguments:
  • a - Equatorial radius (scalar > 0).
  • b - Polar radius (scalar > 0).
Returns:
The signed, 3rd flattening (float or 0), (a - b) / (a + b).

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

a_f2b (a, f)

 

Return b, the polar radius for a given equatorial radius and flattening.

Arguments:
  • a - Equatorial radius (scalar > 0).
  • f - Flattening (scalar < 1, negative for prolate).
Returns:
The polar radius (float), a * (1 - f).

a_f_2b (a, f_)

 

Return b, the polar radius for a given equatorial radius and inverse flattening.

Arguments:
  • a - Equatorial radius (scalar > 0).
  • f_ - Inverse flattening (scalar >>> 1).
Returns:
The polar radius (float), a * (f_ - 1) / f_.

acre2ha (acres)

 

Convert acres to hectare.

Arguments:
  • acres - Value in acres (scalar).
Returns:
Value in hectare (float).
Raises:
  • ValueError - Invalid acres.

acre2m2 (acres)

 

Convert acres to square meter.

Arguments:
  • acres - Value in acres (scalar).
Returns:
Value in meter^2 (float).
Raises:
  • ValueError - Invalid acres.

anStr (name, OKd='._-', sub='_')

 

DEPRECATED, use function pygeodesy.anstr.

Decorators:
  • @deprecated_function

anstr (name, OKd='._-', sub='_')

 

Make a valid name of alphanumeric and OKd characters.

Arguments:
  • name - The original name (str).
  • OKd - Other acceptable characters (str).
  • sub - Substitute for invalid charactes (str).
Returns:
The modified name (str).

Note: Leading and trailing whitespace characters are removed, intermediate whitespace characters are coalesced and substituted.

antipode (lat, lon)

 

Return the antipode, the point diametrically opposite to a given point in degrees.

Arguments:
  • lat - Latitude (degrees).
  • lon - Longitude (degrees).
Returns:
A LatLon2Tuple(lat, lon).

See Also: Geosphere.

antipode_ (phi, lam)

 

Return the antipode, the point diametrically opposite to a given point in radians.

Arguments:
  • phi - Latitude (radians).
  • lam - Longitude (radians).
Returns:
A PhiLam2Tuple(phi, lam).

See Also: Geosphere.

areaOf (points, adjust=True, radius=6371008.77141, wrap=True)

 

Approximate the area of a polygon.

Arguments:
  • points - The polygon points (LatLon[]).
  • adjust - Adjust the wrapped, unrolled longitudinal delta by the cosine of the mean latitude (bool).
  • radius - Mean earth radius (meter) or None.
  • wrap - Wrap lat-, wrap and unroll longitudes (bool).
Returns:
Approximate area (square meter, same units as radius or radians squared if radius is None).
Raises:
  • PointsError - Insufficient number of points
  • TypeError - Some points are not LatLon.
  • ValueError - Invalid radius.

Note: This area approximation has limited accuracy and is ill-suited for regions exceeding several hundred Km or Miles or with near-polar latitudes.

See Also: sphericalNvector.areaOf, sphericalTrigonometry.areaOf and ellipsoidalKarney.areaOf.

areaof (points, adjust=True, radius=6371008.77141, wrap=True)

 

DEPRECATED, use function pygeodesy.areaOf.

Decorators:
  • @deprecated_function

atan2b (y, x)

 

Return atan2(y, x) in degrees [0..+360].

See Also: Function pygeodesy.atan2d.

atan2d (y, x, reverse=False)

 

Return atan2(y, x) in degrees [-180..+180], optionally reversed (by 180 degrees for azi2).

See Also: Karney's C++ function Math.atan2d.

atand (y_x)

 

Return atan(y_x) angle in degrees.

See Also: Function pygeodesy.atan2d.

attrs (inst, *names, **Nones_True__pairs_kwds)

 

Get instance attributes as name=value strings, with floats formatted by function fstr.

Arguments:
  • inst - The instance (any type).
  • names - The attribute names, all other positional (str).
  • Nones_True__pairs_kwds - Keyword argument for function pairs, except Nones=True to in-/exclude missing or None-valued attributes.
Returns:
A tuple(sep.join(t) for t in zip(names, reprs(values, ...))) of strs.

b_f2a (b, f)

 

Return a, the equatorial radius for a given polar radius and flattening.

Arguments:
  • b - Polar radius (scalar > 0).
  • f - Flattening (scalar < 1, negative for prolate).
Returns:
The equatorial radius (float), b / (1 - f).

b_f_2a (b, f_)

 

Return a, the equatorial radius for a given polar radius and inverse flattening.

Arguments:
  • b - Polar radius (scalar > 0).
  • f_ - Inverse flattening (scalar >>> 1).
Returns:
The equatorial radius (float), b * f_ / (f_ - 1).

bearing (lat1, lon1, lat2, lon2, **options)

 

Compute the initial or final bearing (forward or reverse azimuth) between a (spherical) start and end point.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • options - Optional keyword arguments for function pygeodesy.bearing_.
Returns:
Initial or final bearing (compass degrees360) or zero if start and end point coincide.

bearingDMS (bearing, form='d', prec=None, sep='', **s_D_M_S)

 

Convert bearing to a string (without compass point suffix).

Arguments:
Returns:
Compass degrees per the specified form (str).

See Also: Function pygeodesy.toDMS.

JS name: toBrng.

bearing_ (phi1, lam1, phi2, lam2, final=False, wrap=False)

 

Compute the initial or final bearing (forward or reverse azimuth) between a (spherical) start and end point.

Arguments:
  • phi1 - Start latitude (radians).
  • lam1 - Start longitude (radians).
  • phi2 - End latitude (radians).
  • lam2 - End longitude (radians).
  • final - Return final bearing if True, initial otherwise (bool).
  • wrap - Wrap and pygeodesy.unrollPI longitudes (bool).
Returns:
Initial or final bearing (compass radiansPI2) or zero if start and end point coincide.

bounds (points, wrap=True, LatLon=None)

 

DEPRECATED, use function pygeodesy.boundsOf.

Returns:
2-Tuple (latlonSW, latlonNE) as LatLon or 4-Tuple (latS, lonW, latN, lonE) if LatLon is None.
Decorators:
  • @deprecated_function

boundsOf (points, wrap=True, LatLon=None)

 

Determine the lower-left SW and upper-right NE corners of a path or polygon.

Arguments:
  • points - The path or polygon points (LatLon[]).
  • wrap - Wrap lat- and longitudes (bool).
  • LatLon - Optional class to return the bounds corners (LatLon) or None.
Returns:
A Bounds2Tuple(latlonSW, latlonNE) as LatLons if LatLon is None a Bounds4Tuple(latS, lonW, latN, lonE).
Raises:
  • PointsError - Insufficient number of points
  • TypeError - Some points are not LatLon.

See Also: Function quadOf.

Example:

>>> b = LatLon(45,1), LatLon(45,2), LatLon(46,2), LatLon(46,1)
>>> boundsOf(b)  # False
>>> 45.0, 1.0, 46.0, 2.0

callername (up=1, dflt='', source=False, underOK=False)

 

Get the name of the invoking callable.

Arguments:
  • up - Number of call stack frames up (int).
  • dflt - Default return value (any).
  • source - Include source file name and line number (bool).
  • underOK - Private, internal callables are OK (bool).
Returns:
The callable name (str) or dflt if none found.

cassini (pointA, pointB, pointC, alpha, beta, useZ=False, Clas=None, **Clas_kwds)

 

3-Point resection using Cassini's method.

Arguments:
  • pointA - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • pointB - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • pointC - Center point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • alpha - Angle subtended by triangle side pointA to pointC (degrees, non-negative).
  • beta - Angle subtended by triangle side pointB to pointC (degrees, non-negative).
  • useZ - If True, use and interpolate the Z component, otherwise force z=INT0 (bool).
  • Clas - Optional class to return the survey and auxiliary point or None for pointA's (sub-)class.
  • Clas_kwds - Optional additional keyword argument for the survey and auxiliary point instance.
Returns:
The survey point, an instance of Clas or if Clas is None of pointA's (sub-)class.
Raises:
  • ResectionError - Near-coincident, -colinear or -concyclic points or negative or invalid alpha or beta.
  • TypeError - Invalid pointA, pointB or pointM.

Note: Typically, pointC is between pointA and pointB.

See Also: Three Point Resection Problem and functions pygeodesy.collins5, pygeodesy.pierlot and pygeodesy.tienstra7.

cbrt (x3)

 

Compute the cube root x3**(1/3).

Arguments:
  • x3 - Value (scalar).
Returns:
Cubic root (float).

See Also: Functions cbrt2 and sqrt3.

cbrt2 (x3)

 

Compute the cube root squared x3**(2/3).

Arguments:
  • x3 - Value (scalar).
Returns:
Cube root squared (float).

See Also: Functions cbrt and sqrt3.

centroidOf (points, wrap=True, LatLon=None)

 

Determine the centroid of a polygon.

Arguments:
  • points - The polygon points (LatLon[]).
  • wrap - Wrap lat-, wrap and unroll longitudes (bool).
  • LatLon - Optional class to return the centroid (LatLon) or None.
Returns:
Centroid (LatLon) or a LatLon2Tuple(lat, lon) if LatLon is None.
Raises:
  • PointsError - Insufficient number of points
  • TypeError - Some points are not LatLon.
  • ValueError - The points enclose a pole or near-zero area.

See Also: Centroid and Paul Bourke's Calculating The Area And Centroid Of A Polygon, 1988.

chain2m (chains)

 

Convert UK chains to meter.

Arguments:
  • chains - Value in chains (scalar).
Returns:
Value in meter (float).
Raises:
  • ValueError - Invalid chains.

circin6 (point1, point2, point3, eps=8.881784197e-16, useZ=True)

 

Return the radius and center of the inscribed aka In- circle of a (2- or 3-D) triangle.

Arguments:
  • point1 - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • point2 - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • point3 - Third point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • eps - Tolerance for function pygeodesy.trilaterate3d2 if useZ is True otherwise pygeodesy.trilaterate2d2.
  • useZ - If True, use the Z components, otherwise force z=INT0 (bool).
Returns:
Circin6Tuple(radius, center, deltas, cA, cB, cC). The center and contact points cA, cB and cC, each an instance of point1's (sub-)class, are co-planar with the three given points.
Raises:
  • ImportError - Package numpy not found, not installed or older than version 1.10 and useZ is True.
  • IntersectionError - Near-coincident or -colinear points or a trilateration or numpy issue.
  • TypeError - Invalid point1, point2 or point3.

See Also: Functions radii11 and circum3, Incircle and Contact Triangle.

circle4 (earth, lat)

 

Get the equatorial or a parallel circle of latitude.

Arguments:
Returns:
A Circle4Tuple(radius, height, lat, beta) instance.
Raises:

circum3 (point1, point2, point3, circum=True, eps=8.881784197e-16, useZ=True)

 

Return the radius and center of the smallest circle through or containing three (2- or 3-D) points.

Arguments:
  • point1 - First point (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • point2 - Second point (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • point3 - Third point (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • circum - If True return the circumradius and circumcenter always, ignoring the Meeus' Type I case (bool).
  • eps - Tolerance for function pygeodesy.trilaterate3d2 if useZ is True otherwise pygeodesy.trilaterate2d2.
  • useZ - If True, use the Z components, otherwise force z=INT0 (bool).
Returns:
A Circum3Tuple(radius, center, deltas). The center, an instance of point1's (sub-)class, is co-planar with the three given points.
Raises:
  • ImportError - Package numpy not found, not installed or older than version 1.10 and useZ is True.
  • IntersectionError - Near-coincident or -colinear points or a trilateration or numpy issue.
  • TypeError - Invalid point1, point2 or point3.

circum4_ (*points, **Vector_and_kwds)

 

Best-fit a sphere through three or more (3-D) points.

Arguments:
  • points - The points (each a Cartesian, Vector3d, Vector3Tuple, or Vector4Tuple).
  • Vector_and_kwds - Optional class Vector=None to return the center and optional, additional Vector keyword arguments, otherwise the first points' (sub-)class.
Returns:
Circum4Tuple(radius, center, rank, residuals) with center an instance of points[0]' (sub-)class or Vector if specified.
Raises:
  • ImportError - Package numpy not found, not installed or older than version 1.10.
  • NumPyError - Some numpy issue.
  • PointsError - Too few points.
  • TypeError - One of the points is invalid.

classname (inst, prefixed=None)

 

Return the instance' class name optionally prefixed with the module name.

Arguments:
  • inst - The object (any type).
  • prefixed - Include the module name (bool), see function classnaming.
Returns:
The inst's [module.]class name (str).

classnaming (prefixed=None)

 

Get/set the default class naming for [module.]class names.

Arguments:
  • prefixed - Include the module name (bool).
Returns:
Previous class naming setting (bool).

clipCS3 (points, lowerleft, upperright, closed=False, inull=False)

 

DEPRECATED, use function pygeodesy.clipCS4.

Returns:
Yield a ClipCS3Tuple(start, end, index) for each edge of the clipped path.
Decorators:
  • @deprecated_function

clipCS4 (points, lowerleft, upperright, closed=False, inull=False)

 

Clip a path against a rectangular clip box using the Cohen-Sutherland algorithm.

Arguments:
  • points - The points (LatLon[]).
  • lowerleft - Bottom-left corner of the clip box (LatLon).
  • upperright - Top-right corner of the clip box (LatLon).
  • closed - Optionally, close the path (bool).
  • inull - Optionally, retain null edges if inside (bool).
Returns:
Yield a ClipCS4Tuple(start, end, i, j) for each edge of the clipped path.
Raises:
  • ClipError - The lowerleft and upperright corners specify an invalid clip box.
  • PointsError - Insufficient number of points.

clipDMS (deg, limit)

 

DEPRECATED, use function pygeodesy.clipDegrees.

Decorators:
  • @deprecated_function

clipDegrees (deg, limit)

 

Clip a lat- or longitude to the given range.

Arguments:
  • deg - Unclipped lat- or longitude (scalar degrees).
  • limit - Valid -/+limit range (degrees).
Returns:
Clipped value (degrees).
Raises:

clipLB6 (points, lowerleft, upperright, closed=False, inull=False)

 

Clip a path against a rectangular clip box using the Liang-Barsky algorithm.

Arguments:
  • points - The points (LatLon[]).
  • lowerleft - Bottom-left corner of the clip box (LatLon).
  • upperright - Top-right corner of the clip box (LatLon).
  • closed - Optionally, close the path (bool).
  • inull - Optionally, retain null edges if inside (bool).
Returns:
Yield a ClipLB6Tuple(start, end, i, fi, fj, j) for each edge of the clipped path.
Raises:
  • ClipError - The lowerleft and upperright corners specify an invalid clip box.
  • PointsError - Insufficient number of points.

clipRadians (rad, limit)

 

Clip a lat- or longitude to the given range.

Arguments:
  • rad - Unclipped lat- or longitude (radians).
  • limit - Valid -/+limit range (radians).
Returns:
Clipped value (radians).
Raises:

clipSH (points, corners, closed=False, inull=False)

 

Clip a polygon against a clip region or box using the Sutherland-Hodgman algorithm.

Arguments:
  • points - The polygon points (LatLon[]).
  • corners - Three or more points defining a convex clip region (LatLon[]) or two points to specify a rectangular clip box.
  • closed - Close the clipped points (bool).
  • inull - Optionally, include null edges (bool).
Returns:
Yield the clipped points (LatLon[]).
Raises:
  • ClipError - The corners specify a polar, zero-area, non-convex or otherwise invalid clip box or region.
  • PointsError - Insufficient number of points.

clipSH3 (points, corners, closed=False, inull=False)

 

Clip a polygon against a clip region or box using the Sutherland-Hodgman algorithm.

Arguments:
  • points - The polygon points (LatLon[]).
  • corners - Three or more points defining a convex clip region (LatLon[]) or two points to specify a rectangular clip box.
  • closed - Close the clipped points (bool).
  • inull - Optionally, include null edges (bool).
Returns:
Yield a ClipSH3Tuple(start, end, original) for each edge of the clipped polygon.
Raises:
  • ClipError - The corners specify a polar, zero-area, non-convex or otherwise invalid clip box or region.
  • PointsError - Insufficient number of points.

clipStr (bstr, limit=50, white='')

 

DEPRECATED, use function pygeodesy.clips.

Decorators:
  • @deprecated_function

clips (bstr, limit=50, white='')

 

Clip a string to the given length limit.

Arguments:
  • bstr - String (bytes or str).
  • limit - Length limit (int).
  • white - Optionally, replace all whitespace (str).
Returns:
The clipped or unclipped bstr.

collins (pointA, pointB, pointC, alpha, beta, **useZ_Clas_and_kwds)

 

DEPRECATED, use function pygeodesy.collins5.

Decorators:
  • @deprecated_function

collins5 (pointA, pointB, pointC, alpha, beta, useZ=False, Clas=None, **Clas_kwds)

 

3-Point resection using Collins' method.

Arguments:
  • pointA - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • pointB - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • pointC - Center point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • alpha - Angle subtended by triangle side b from pointA to pointC (degrees, non-negative).
  • beta - Angle subtended by triangle side a from pointB to pointC (degrees, non-negative).
  • useZ - If True, use and interpolate the Z component, otherwise force z=INT0 (bool).
  • Clas - Optional class to return the survey point or None for pointA's (sub-)class.
  • Clas_kwds - Optional additional keyword argument for the survey point instance.
Returns:
Collins5Tuple(pointP, pointH, a, b, c) with survey pointP, auxiliary pointH, each an instance of Clas or if Clas is None of pointA's (sub-)class and triangle sides a, b and c in meter, conventionally.
Raises:
  • ResectionError - Near-coincident, -colinear or -concyclic points or negative or invalid alpha or beta.
  • TypeError - Invalid pointA, pointB or pointM.

Note: Typically, pointC is between pointA and pointB.

See Also: Collins' methode and functions pygeodesy.cassini, pygeodesy.pierlot and pygeodesy.tienstra7.

compassAngle (lat1, lon1, lat2, lon2, adjust=True, wrap=False)

 

Return the angle from North for the direction vector (lon2 - lon1, lat2 - lat1) between two points.

Suitable only for short, not near-polar vectors up to a few hundred Km or Miles. Use function pygeodesy.bearing for longer vectors.

Arguments:
  • lat1 - From latitude (degrees).
  • lon1 - From longitude (degrees).
  • lat2 - To latitude (degrees).
  • lon2 - To longitude (degrees).
  • adjust - Adjust the longitudinal delta by the cosine of the mean latitude (bool).
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Compass angle from North (degrees360).

Note: Courtesy of Martin Schultz.

See Also: Local, flat earth approximation.

compassDMS (bearing, form='d', prec=None, sep='', **s_D_M_S)

 

Convert bearing to a string suffixed with compass point.

Arguments:
Returns:
Compass degrees and point in the specified form (str).

See Also: Function pygeodesy.toDMS.

compassPoint (bearing, prec=3)

 

Convert bearing to a compass point.

Arguments:
  • bearing - Bearing from North (compass degrees360).
  • prec - Precision, number of compass point characters: 1 for cardinal or basic winds, 2 for intercardinal or ordinal or principal winds, 3 for secondary-intercardinal or half-winds or 4 for quarter-winds).
Returns:
Compass point (1-, 2-, 3- or 4-letter str).
Raises:
  • ValueError - Invalid prec.

See Also: Dms.compassPoint and Compass rose.

Example:

>>> p = compassPoint(24, 1)  # 'N'
>>> p = compassPoint(24, 2)  # 'NE'
>>> p = compassPoint(24, 3)  # 'NNE'
>>> p = compassPoint(24)     # 'NNE'
>>> p = compassPoint(11, 4)  # 'NbE'
>>> p = compassPoint(30, 4)  # 'NEbN'
>>> p = compassPoint(11.249)  # 'N'
>>> p = compassPoint(11.25)   # 'NNE'
>>> p = compassPoint(-11.25)  # 'N'
>>> p = compassPoint(348.749) # 'NNW'

copysign0 (x, y)

 

Like math.copysign(x, y) except zero, unsigned.

Returns:
math.copysign(x, y) if x else type(x)(0).

copytype (x, y)

 

Return the value of x as type of y.

Returns:
type(y)(x).

cosineAndoyerLambert (lat1, lon1, lat2, lon2, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., wrap=False)

 

Compute the distance between two (ellipsoidal) points using the Andoyer-Lambert correction of the Law of Cosines fromula.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • datum - Datum or ellipsoid to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Distance (meter, same units as the datum's ellipsoid axes or radians if datum is None).
Raises:
  • TypeError - Invalid datum.

cosineAndoyerLambert_ (phi2, phi1, lam21, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...)

 

Compute the angular distance between two (ellipsoidal) points using the Andoyer-Lambert correction of the Law of Cosines fromula.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
  • datum - Datum or ellipsoid to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
Returns:
Angular distance (radians).
Raises:
  • TypeError - Invalid datum.

cosineForsytheAndoyerLambert (lat1, lon1, lat2, lon2, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., wrap=False)

 

Compute the distance between two (ellipsoidal) points using the Forsythe-Andoyer-Lambert correction of the Law of Cosines formula.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • datum - Datum or ellipsoid to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Distance (meter, same units as the datum's ellipsoid axes or radians if datum is None).
Raises:
  • TypeError - Invalid datum.

cosineForsytheAndoyerLambert_ (phi2, phi1, lam21, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...)

 

Compute the angular distance between two (ellipsoidal) points using the Forsythe-Andoyer-Lambert correction of the Law of Cosines formula.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
  • datum - Datum or ellipsoid to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
Returns:
Angular distance (radians).
Raises:
  • TypeError - Invalid datum.

cosineLaw (lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)

 

Compute the distance between two points using the spherical Law of Cosines formula.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • radius - Mean earth radius, ellipsoid or datum (meter, Ellipsoid, Ellipsoid2, Datum or a_f2Tuple).
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Distance (meter, same units as radius or the ellipsoid or datum axes).
Raises:
  • TypeError - Invalid radius.

cosineLaw_ (phi2, phi1, lam21)

 

Compute the angular distance between two points using the spherical Law of Cosines formula.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
Returns:
Angular distance (radians).

cot (rad, **error_kwds)

 

Return the cotangent of an angle in radians.

Arguments:
  • rad - Angle (radians).
  • error_kwds - Error to raise (ValueError).
Returns:
cot(rad).
Raises:

cot_ (*rads, **error_kwds)

 

Return the cotangent of angle(s) in radiansresection.

Arguments:
  • rads - One or more angles (radians).
  • error_kwds - Error to raise (ValueError).
Returns:
Yield the cot(rad) for each angle.
Raises:

cotd (deg, **error_kwds)

 

Return the cotangent of an angle in degrees.

Arguments:
  • deg - Angle (degrees).
  • error_kwds - Error to raise (ValueError).
Returns:
cot(deg).
Raises:

cotd_ (*degs, **error_kwds)

 

Return the cotangent of angle(s) in degrees.

Arguments:
  • degs - One or more angles (degrees).
  • error_kwds - Error to raise (ValueError).
Returns:
Yield the cot(deg) for each angle.
Raises:

crosserrors (raiser=None)

 

Report or ignore vectorial cross product errors.

Arguments:
  • raiser - Use True to throw or False to ignore CrossError exceptions. Use None to leave the setting unchanged.
Returns:
Previous setting (bool).

See Also: Property Vector3d[Base].crosserrors.

date2epoch (year, month, day)

 

Return the reference frame epoch for a calendar day.

Arguments:
  • year - Year of the date (scalar).
  • month - Month in the year (scalar, 1..12).
  • day - Day in the month (scalar, 1..31).
Returns:
Epoch, the fractional year (float).
Raises:
  • TRFError - Invalid year, month or day.

Note: Any year is considered a leap year, i.e. having 29 days in February.

decodeEPSG2 (arg)

 

DEPRECATED, use function epsg.decode2.

Returns:
2-Tuple (zone, hemipole)
Decorators:
  • @deprecated_function

degDMS (deg, prec=6, s_D='°', s_M='\xe2\x80\xb2', s_S='', neg='-', pos='')

 

Convert degrees to a string in degrees, minutes or seconds.

Arguments:
  • deg - Value in degrees (scalar degrees).
  • prec - Number of decimal digits (0..9 or None for default). Trailing zero decimals are stripped for prec values of 1 and above, but kept for negative prec.
  • s_D - D symbol for degrees (str).
  • s_M - M symbol for minutes (str) or "".
  • s_S - S symbol for seconds (str) or "".
  • neg - Optional sign for negative ('-').
  • pos - Optional sign for positive ('').
Returns:
Either degrees, minutes or seconds (str).

See Also: Function pygeodesy.toDMS.

degrees180 (rad)

 

Convert radians to degrees and wrap [-180..+180].

Arguments:
  • rad - Angle (radians).
Returns:
Angle, wrapped (degrees180).

degrees2grades (deg)

 

Convert degrees to grades (aka gons or gradians).

Arguments:
  • deg - Angle (degrees).
Returns:
Angle (grades).

degrees2m (deg, radius=6371008.77141, lat=0)

 

Convert an angle to a distance along the equator or along the parallel at an other (geodetic) latitude.

Arguments:
  • deg - The angle (degrees).
  • radius - Mean earth radius, ellipsoid or datum (meter, Ellipsoid, Ellipsoid2, Datum or a_f2Tuple).
  • lat - Parallel latitude (degrees90, str).
Returns:
Distance (meter, same units as radius or equatorial and polar radii) or 0.0 for near-polar lat.
Raises:
  • RangeError - Latitude lat outside valid range and pygeodesy.rangerrors set to True.
  • TypeError - Invalid radius.
  • ValueError - Invalid deg, radius or lat.

See Also: Function radians2m and m2degrees.

degrees360 (rad)

 

Convert radians to degrees and wrap [0..+360).

Arguments:
  • rad - Angle (radians).
Returns:
Angle, wrapped (degrees360).

degrees90 (rad)

 

Convert radians to degrees and wrap [-270..+90].

Arguments:
  • rad - Angle (radians).
Returns:
Angle, wrapped (degrees90).

deprecated_Property_RO (method)

 

Decorator for a DEPRECATED Property_RO.

Arguments:
  • method - The Property_RO.fget method (callable).
Returns:
The method DEPRECATED.

deprecated_class (cls_or_class)

 

Use inside __new__ or __init__ of a DEPRECATED class.

Arguments:
  • cls_or_class - The class (cls or Class).

Note: NOT a decorator!

deprecated_function (call)

 

Decorator for a DEPRECATED function.

Arguments:
  • call - The deprecated function (callable).
Returns:
The call DEPRECATED.

deprecated_method (call)

 

Decorator for a DEPRECATED method.

Arguments:
  • call - The deprecated method (callable).
Returns:
The call DEPRECATED.

deprecated_property_RO (method)

 

Decorator for a DEPRECATED property_RO.

Arguments:
  • method - The property_RO.fget method (callable).
Returns:
The method DEPRECATED.

egmGeoidHeights (GeoidHeights_dat)

 

Generate geoid egm*.pgm height tests from GeoidHeights.dat Test data for Geoids.

Arguments:
  • GeoidHeights_dat - The un-gz-ed GeoidHeights.dat file (str or file handle).
Returns:
For each test, yield a GeoidHeight5Tuple(lat, lon, egm84, egm96, egm2008).
Raises:

Note: Function egmGeoidHeights is used to test the geoids GeoidKarney and GeoidPGM, see PyGeodesy module test/testGeoids.py.

elevation2 (lat, lon, timeout=2.0)

 

Get the geoid elevation at an NAD83 to NAVD88 location.

Arguments:
  • lat - Latitude (degrees).
  • lon - Longitude (degrees).
  • timeout - Optional, query timeout (seconds).
Returns:
An Elevation2Tuple(elevation, data_source) or (None, "error") in case of errors.
Raises:
  • ValueError - Invalid timeout.

Note: The returned elevation is None if lat or lon is invalid or outside the Conterminous US (CONUS), if conversion failed or if the query timed out. The "error" is the HTTP-, IO-, SSL- or other -Error as a string (str).

See Also: USGS National Map, the FAQ, geoid.py, module geoids, classes GeoidG2012B, GeoidKarney and GeoidPGM.

enStr2 (easting, northing, prec, *extras)

 

DEPRECATED, use function pygeodesy.enstr2.

Decorators:
  • @deprecated_function

encodeEPSG (zone, hemipole='', band='')

 

DEPRECATED, use function epsg.encode.

Returns:
EPSG code (int).
Decorators:
  • @deprecated_function

enstr2 (easting, northing, prec, *extras)

 

Return easting, northing string representations.

Arguments:
  • easting - Easting from false easting (meter).
  • northing - Northing from from false northing (meter).
  • prec - Precision in number of digits (int, 2..10).
  • extras - Optional leading items (strs).
Returns:
extras + 2-Tuple (eastingStr, northingStr).
Raises:
  • ValueError - Invalid prec.

epoch2date (epoch)

 

Return the date for a reference frame epoch.

Arguments:
  • epoch - Fractional year (scalar).
Returns:
3-Tuple (year, month, day).
Raises:

Note: Any year is considered a leap year, i.e. having 29 days in February.

equidistant (lat0, lon0, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., exact=False, geodsolve=False, name='')

 

Return an EquidistantExact, EquidistantGeodSolve or (if Karney's geographiclib package is installed) an EquidistantKarney, otherwise an Equidistant instance.

Arguments:
  • lat0 - Latitude of center point (degrees90).
  • lon0 - Longitude of center point (degrees180).
  • datum - Optional datum or ellipsoid (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple) or scalar earth radius (meter).
  • exact - Return an EquidistantExact instance.
  • geodsolve - Return an EquidistantGeodSolve instance.
  • name - Optional name for the projection (str).
Returns:
An EquidistantExact, EquidistantGeodSolve, EquidistantKarney or Equidistant instance.
Raises:

equirectangular (lat1, lon1, lat2, lon2, radius=6371008.77141, **options)

 

Compute the distance between two points using the Equirectangular Approximation / Projection.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • radius - Mean earth radius, ellipsoid or datum (meter, Ellipsoid, Ellipsoid2, Datum or a_f2Tuple).
  • options - Optional keyword arguments for function equirectangular_.
Returns:
Distance (meter, same units as radius or the ellipsoid or datum axes).
Raises:
  • TypeError - Invalid radius.

See Also: Function equirectangular_ for more details, the available options, errors, restrictions and other, approximate or accurate distance functions.

equirectangular3 (lat1, lon1, lat2, lon2, **options)

 

DEPRECATED, use function equirectangular_.

Returns:
3-Tuple (distance2, delta_lat, delta_lon).
Decorators:
  • @deprecated_function

equirectangular_ (lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap=False)

 

Compute the distance between two points using the Equirectangular Approximation / Projection.

This approximation is valid for short distance of several hundred Km or Miles, see the limit keyword argument and the LimitError.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • adjust - Adjust the wrapped, unrolled longitudinal delta by the cosine of the mean latitude (bool).
  • limit - Optional limit for lat- and longitudinal deltas (degrees) or None or 0 for unlimited.
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
A Distance4Tuple(distance2, delta_lat, delta_lon, unroll_lon2).
Raises:

euclid (x, y)

 

Appoximate the norm sqrt(x**2 + y**2) by max(abs(x), abs(y)) + min(abs(x), abs(y)) * 0.4142....

Arguments:
  • x - X component (scalar).
  • y - Y component (scalar).
Returns:
Appoximate norm (float).

See Also: Function euclid_.

euclid_ (*xs)

 

Appoximate the norm sqrt(sum(x**2 for x in xs)) by cascaded euclid.

Arguments:
  • xs - X arguments, positional (scalars).
Returns:
Appoximate norm (float).

See Also: Function euclid.

euclidean (lat1, lon1, lat2, lon2, radius=6371008.77141, adjust=True, wrap=False)

 

Approximate the Euclidean distance between two (spherical) points.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • radius - Mean earth radius, ellipsoid or datum (meter, Ellipsoid, Ellipsoid2, Datum or a_f2Tuple).
  • adjust - Adjust the longitudinal delta by the cosine of the mean latitude (bool).
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Distance (meter, same units as radius or the ellipsoid or datum axes).
Raises:
  • TypeError - Invalid radius.

euclidean_ (phi2, phi1, lam21, adjust=True)

 

Approximate the angular Euclidean distance between two (spherical) points.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
  • adjust - Adjust the longitudinal delta by the cosine of the mean latitude (bool).
Returns:
Angular distance (radians).

exception_chaining (error=None)

 

Get the previous exception's or exception chaining setting.

Arguments:
  • error - An error instance (Exception) or None.
Returns:
If error is None, return True if exception chaining is enabled for PyGeodesy errors, False if turned off and None if not available. If error is not None, return the previous, chained error or None otherwise.

Note: Set env var PYGEODESY_EXCEPTION_CHAINING to any non-empty value prior to import pygeodesy to enable exception chaining for pygeodesy errors.

excessAbc (A, b, c)

 

Compute the spherical excess E of a (spherical) triangle from two sides and the included angle.

Arguments:
  • A - An interior triangle angle (radians).
  • b - Frist adjacent triangle side (radians).
  • c - Second adjacent triangle side (radians).
Returns:
Spherical excess (radians).
Raises:

excessGirard (A, B, C)

 

Compute the spherical excess E of a (spherical) triangle using Girard's formula.

Arguments:
  • A - First interior triangle angle (radians).
  • B - Second interior triangle angle (radians).
  • C - Third interior triangle angle (radians).
Returns:
Spherical excess (radians).
Raises:

See Also: Function excessLHuilier, Spherical trigonometry.

excessKarney (lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)

 

Compute the surface area of a (spherical) quadrilateral bounded by a segment of a great circle, two meridians and the equator using Karney's method.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • radius - Mean earth radius, ellipsoid or datum (meter, Ellipsoid, Ellipsoid2, Datum or a_f2Tuple) or None.
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Surface area, signed (square meter, or units of radius squared) or spherical excess (radians) if radius is None or 0.
Raises:
  • TypeError - Invalid radius.
  • UnitError - Invalid lat2 or lat1.
  • ValueError - Semi-circular longitudinal delta.

See Also: Function excessKarney_ and excessQuad.

excessKarney_ (phi2, phi1, lam21)

 

Compute the spherical excess E of a (spherical) quadrilateral bounded by a segment of a great circle, two meridians and the equator using Karney's method.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
Returns:
Spherical excess, signed (radians).
Raises:
  • ValueError - Semi-circular longitudinal delta lam21.

excessLHuilier (a, b, c)

 

Compute the spherical excess E of a (spherical) triangle using L'Huilier's Theorem.

Arguments:
  • a - First triangle side (radians).
  • b - Second triangle side (radians).
  • c - Third triangle side (radians).
Returns:
Spherical excess (radians).
Raises:

See Also: Function excessGirard, Spherical trigonometry.

excessQuad (lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)

 

Compute the surface area of a (spherical) quadrilateral bounded by a segment of a great circle, two meridians and the equator.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • radius - Mean earth radius, ellipsoid or datum (meter, Ellipsoid, Ellipsoid2, Datum or a_f2Tuple) or None.
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Surface area, signed (square meter, or units of radius squared) or spherical excess (radians) if radius is None or 0.
Raises:
  • TypeError - Invalid radius.
  • UnitError - Invalid lat2 or lat1.

See Also: Function excessQuad_ and excessKarney.

excessQuad_ (phi2, phi1, lam21)

 

Compute the spherical excess E of a (spherical) quadrilateral bounded by a segment of a great circle, two meridians and the equator.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
Returns:
Spherical excess, signed (radians).

See Also: Function excessQuad, Spherical trigonometry.

f2e2 (f)

 

Return e2, the 1st eccentricity squared for a given flattening.

Arguments:
  • f - Flattening (scalar < 1, negative for prolate).
Returns:
The signed, (1st) eccentricity squared (float < 1), f * (2 - f).

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

See Also: Eccentricity conversions and Flattening.

f2e22 (f)

 

Return e22, the 2nd eccentricity squared for a given flattening.

Arguments:
  • f - Flattening (scalar < 1, negative for prolate).
Returns:
The signed, 2nd eccentricity squared (float > -1 or INF), f * (2 - f) / (1 - f)**2.

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

See Also: Eccentricity conversions.

f2e32 (f)

 

Return e32, the 3rd eccentricity squared for a given flattening.

Arguments:
  • f - Flattening (scalar < 1, negative for prolate).
Returns:
The signed, 3rd eccentricity squared (float), f * (2 - f) / (1 + (1 - f)**2).

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

See Also: Eccentricity conversions.

f2f2 (f)

 

Return f2, the 2nd flattening for a given flattening.

Arguments:
  • f - Flattening (scalar < 1, negative for prolate).
Returns:
The signed, 2nd flattening (float or INF), f / (1 - f).

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

See Also: Eccentricity conversions and Flattening.

f2f_ (f)

 

Return f_, the inverse flattening for a given flattening.

Arguments:
  • f - Flattening (scalar < 1, negative for prolate).
Returns:
The inverse flattening (float or 0), 1 / f.

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

f2n (f)

 

Return n, the 3rd flattening for a given flattening.

Arguments:
  • f - Flattening (scalar < 1, negative for prolate).
Returns:
The signed, 3rd flattening (-1 <= float < 1), f / (2 - f).

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

See Also: Eccentricity conversions and Flattening.

fStr (floats, prec=6, fmt='f', ints=False, sep=', ')

 

DEPRECATED, use function fstr.

Decorators:
  • @deprecated_function

fStrzs (floatstr)

 

DEPRECATED, use function pygeodesy.fstrzs.

Decorators:
  • @deprecated_function

f_2f (f_)

 

Return f, the flattening for a given inverse flattening.

Arguments:
  • f_ - Inverse flattening (scalar >>> 1).
Returns:
The flattening (float or 0), 1 / f_.

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

facos1 (x)

 

Fast approximation of pygeodesy.acos1(x).

See Also: ShaderFastLibs.h.

false2f (value, name='value', false=True, Error=<type 'exceptions.ValueError'>)

 

DEPRECATED, use function falsed2f.

Decorators:
  • @deprecated_function

falsed2f (falsed=True, Error=<type 'exceptions.ValueError'>, **name_value)

 

DEPRECATED, use class Easting or Northing.

Convert a falsed east-/northing to non-negative float.

Arguments:
  • falsed - Value includes false origin (bool).
  • Error - Optional, overriding error (Exception).
  • name_value - One name=value pair.
Returns:
The value (float).
Decorators:
  • @deprecated_function
Raises:
  • Error - Invalid or negative name=value.

fasin1 (x)

 

Fast approximation of pygeodesy.asin1(x).

See Also: facos1.

fatan1 (x)

 

Fast approximation of atan(x) for 0 <= x <= 1, unchecked.

See Also: ShaderFastLibs.h and Efficient approximations for the arctangent function, IEEE Signal Processing Magazine, 111, May 2006.

fatan2 (y, x)

 

Fast approximation of atan2(y, x).

fathom2m (fathoms)

 

Convert Imperial fathom to meter.

Arguments:
  • fathoms - Value in fathoms (scalar).
Returns:
Value in meter (float).
Raises:
  • ValueError - Invalid fathoms.

See Also: Function toise2m, Fathom and Klafter.

favg (v1, v2, f=0.5)

 

Return the average of two values.

Arguments:
  • v1 - One value (scalar).
  • v2 - Other value (scalar).
  • f - Optional fraction (float).
Returns:
v1 + f * (v2 - v1) (float).

fdot (a, *b)

 

Return the precision dot product sum(a[i] * b[i] for i=0..len(a)).

Arguments:
  • a - Iterable, list, tuple, etc. (scalars).
  • b - All positional arguments (scalars).
Returns:
Dot product (float).
Raises:

See Also: Class Fdot and Algorithm 5.10 DotK.

fdot3 (a, b, c, start=0)

 

Return the precision dot product start + sum(a[i] * b[i] * c[i] for i=0..len(a)).

Arguments:
  • a - Iterable, list, tuple, etc. (scalars).
  • b - Iterable, list, tuple, etc. (scalars).
  • c - Iterable, list, tuple, etc. (scalars).
  • start - Optional bias (scalar).
Returns:
Dot product (float).
Raises:
  • LenError - Unequal len(a), len(b) and/or len(c).
  • OverflowError - Partial 2sum overflow.

fhorner (x, *cs)

 

Evaluate the polynomial sum(cs[i] * x**i for i=0..len(cs)) using the Horner form.

Arguments:
  • x - Polynomial argument (scalar).
  • cs - Polynomial coeffients (scalars).
Returns:
Horner value (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • TypeError - Non-scalar x.
  • ValueError - No cs coefficients or x is not finite.

See Also: Function fpolynomial and class Fhorner.

fidw (xs, ds, beta=2)

 

Interpolate using using Inverse Distance Weighting (IDW).

Arguments:
  • xs - Known values (scalars).
  • ds - Non-negative distances (scalars).
  • beta - Inverse distance power (int, 0, 1, 2, or 3).
Returns:
Interpolated value x (float).
Raises:
  • LenError - Unequal or zero len(ds) and len(xs).
  • ValueError - Invalid beta, negative ds value, weighted ds below EPS.

Note: Using beta=0 returns the mean of xs.

flatLocal (lat1, lon1, lat2, lon2, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., wrap=False)

 

Compute the distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • datum - Datum or ellipsoid to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Distance (meter, same units as the datum's ellipsoid axes).
Raises:
  • TypeError - Invalid datum.

Note: The meridional and prime_vertical radii of curvature are taken and scaled at the mean of both latitude.

See Also: Functions flatLocal_ or hubeny_, cosineLaw, flatPolar, cosineAndoyerLambert, cosineForsytheAndoyerLambert, equirectangular, euclidean, haversine, thomas, vincentys, method Ellipsoid.distance2 and local, flat earth approximation.

flatLocal_ (phi2, phi1, lam21, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...)

 

Compute the angular distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
  • datum - Datum or ellipsoid to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
Returns:
Angular distance (radians).
Raises:
  • TypeError - Invalid datum.

Note: The meridional and prime_vertical radii of curvature are taken and scaled at the mean of both latitude.

See Also: Functions flatLocal or hubeny, cosineAndoyerLambert_, cosineForsytheAndoyerLambert_, cosineLaw_, flatPolar_, equirectangular_, euclidean_, haversine_, thomas_ and vincentys_ and local, flat earth approximation.

flatPolar (lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)

 

Compute the distance between two (spherical) points using the polar coordinate flat-Earth formula.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • radius - Mean earth radius, ellipsoid or datum (meter, Ellipsoid, Ellipsoid2, Datum or a_f2Tuple).
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Distance (meter, same units as radius or the ellipsoid or datum axes).
Raises:
  • TypeError - Invalid radius.

flatPolar_ (phi2, phi1, lam21)

 

Compute the angular distance between two (spherical) points using the polar coordinate flat-Earth formula.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
Returns:
Angular distance (radians).

fmean (xs)

 

Compute the accurate mean sum(xs[i] for i=0..len(xs)) / len(xs).

Arguments:
  • xs - Values (scalar or Fsum instances).
Returns:
Mean value (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • ValueError - No xs values.

fmean_ (*xs)

 

Compute the accurate mean sum(xs[i] for i=0..len(xs)) / len(xs).

Arguments:
  • xs - Values (scalar or Fsum instances).
Returns:
Mean value (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • ValueError - No xs values.

fpolynomial (x, *cs)

 

Evaluate the polynomial sum(cs[i] * x**i for i=0..len(cs)).

Arguments:
  • x - Polynomial argument (scalar).
  • cs - Polynomial coeffients (scalars), all positional.
Returns:
Polynomial value (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • TypeError - Non-scalar x.
  • ValueError - No cs coefficients or x is not finite.

See Also: Function fhorner and class Fpolynomial.

fpowers (x, n, alts=0)

 

Return a series of powers [x**i for i=1..n].

Arguments:
  • x - Value (scalar).
  • n - Highest exponent (int).
  • alts - Only alternating powers, starting with this exponent (int).
Returns:
Powers of x (floats or ints).
Raises:
  • TypeError - Non-scalar x or n not int.
  • ValueError - Non-finite x or non-positive n.

fprod (xs, start=1.0)

 

Iterable product, like math.prod or numpy.prod.

Arguments:
  • xs - Terms to be multiplied as an iterable, list, tuple, etc. (scalars).
  • start - Initial term, also the value returned for an empty xs (scalar).
Returns:
The product (float).

See Also: NumPy.prod.

fractional (points, fi, j=None, wrap=None, LatLon=None, Vector=None, **kwds)

 

Return the point at a given fractional index.

Arguments:
  • points - The points (LatLon[], Numpy2LatLon[], Tuple2LatLon[], Cartesian[], Vector3d[], Vector3Tuple[]).
  • fi - The fractional index (FIx, float or int).
  • j - Optionally, index of the other point (int).
  • wrap - Wrap and unroll longitudes (bool) or None for backward compatible LatLon2Tuple or LatLon with averaged lat- and longitudes. Use True or False to get the fractional point computed method points[fi].intermediateTo.
  • LatLon - Optional class to return the intermediate, fractional point (LatLon) or None.
  • Vector - Optional class to return the intermediate, fractional point (Cartesian, Vector3d) or None.
  • kwds - Optional, additional LatLon or Vector keyword arguments, ignored if both LatLon and Vector are None.
Returns:
A LatLon2Tuple(lat, lon) if wrap, LatLon and Vector all are None, the defaults.

An instance of LatLon if not None or an instance of Vector if not None.

Otherwise with wrap either True or False and LatLon and Vector both None, an instance of points' (sub-)class intermediateTo fractional.

Summarized as follows:

>>>  wrap  | LatLon | Vector | returned type/value
#   -------+--------+--------+--------------+------
#          |        |        | LatLon2Tuple | favg
#    None  |  None  |  None  |   or**       |
#          |        |        | Vector3Tuple | favg
#    None  | LatLon |  None  | LatLon       | favg
#    None  |  None  | Vector | Vector       | favg
#   -------+--------+--------+--------------+------
#    True  |  None  |  None  | points'      | .iTo
#    True  | LatLon |  None  | LatLon       | .iTo
#    True  |  None  | Vector | Vector       | .iTo
#   -------+--------+--------+--------------+------
#    False |  None  |  None  | points'      | .iTo
#    False | LatLon |  None  | LatLon       | .iTo
#    False |  None  | Vector | Vector       | .iTo
# _____
# favg) averaged lat, lon or x, y, z values
# .iTo) value from points[fi].intermediateTo
# **) depends on base class of points[fi]
Raises:
  • IndexError - Fractional index fi invalid or points not subscriptable or not closed.
  • TypeError - Invalid LatLon, Vector or kwds argument.

See Also: Class FIx and method FIx.fractional.

frange (start, number, step=1)

 

Generate a range of floats.

Arguments:
  • start - First value (float).
  • number - The number of floats to generate (int).
  • step - Increment value (float).
Returns:
A generator (floats).

See Also: NumPy.prod.

frechet_ (points1, points2, distance=None, units='')

 

Compute the discrete Fréchet distance between two paths given as sets of points.

Arguments:
  • points1 - First set of points (LatLon[], Numpy2LatLon[], Tuple2LatLon[] or other[]).
  • points2 - Second set of points (LatLon[], Numpy2LatLon[], Tuple2LatLon[] or other[]).
  • distance - Callable returning the distance between a points1 and a points2 point (signature (point1, point2)).
  • units - Optional, the distance units (Unit or str).
Returns:
A Frechet6Tuple(fd, fi1, fi2, r, n, units) where fi1 and fi2 are type int indices into points1 respectively points2.
Raises:

Note: Function frechet_ does not support fractional indices for intermediate points1 and points2.

freduce (function, sequence, initial=...)

 

Apply a function of two arguments cumulatively to the items of a sequence, from left to right, so as to reduce the sequence to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). If initial is present, it is placed before the items of the sequence in the calculation, and serves as a default when the sequence is empty.

Returns: value

fremainder (x, y)

 

Remainder in range [-y / 2, y / 2].

Arguments:
  • x - Numerator (scalar).
  • y - Modulus, denominator (scalar).
Returns:
Remainder (scalar, preserving signed 0.0) or NAN for any non-finite x.
Raises:
  • ValueError - Infinite or near-zero y.

See Also: Karney's Math.remainder and Python 3.7+ math.remainder.

fstr (floats, prec=6, fmt='F', ints=False, sep=', ', strepr=None)

 

Convert one or more floats to string, optionally stripped of trailing zero decimals.

Arguments:
  • floats - Single or a list, sequence, tuple, etc. (scalars).
  • prec - The float precision, number of decimal digits (0..9). Trailing zero decimals are stripped if prec is positive, but kept for negative prec values. In addition, trailing decimal zeros are stripped for alternate, form '#'.
  • fmt - Optional, float format (str).
  • ints - Optionally, remove the decimal dot for int values (bool).
  • sep - Separator joining the floats (str).
  • strepr - Optional callable to format non-floats (typically repr, str) or None to raise a TypeError.
Returns:
The sep.join(strs(floats, ...) joined (str) or single strs((floats,), ...) (str) if floats is scalar.

fstrzs (efstr, ap1z=False)

 

Strip trailing zero decimals from a float string.

Arguments:
  • efstr - Float with or without exponent (str).
  • ap1z - Append the decimal point and one zero decimal if the efstr is all digits (bool).
Returns:
Float (str).

fsum (xs)

 

Precision floating point summation based on or like Python's math.fsum.

Arguments:
  • xs - Iterable, list, tuple, etc. of values (scalar or Fsum instances).
Returns:
Precision fsum (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • TypeError - Non-scalar xs value.
  • ValueError - Invalid or non-finite xs value.

Note: Exceptions and non-finite handling may differ if not based on Python's math.fsum.

See Also: Class Fsum and methods Fsum.fsum and Fsum.fadd.

fsum1 (xs)

 

Precision floating point summation of a few values, 1-primed.

Arguments:
  • xs - Iterable, list, tuple, etc. of values (scalar or Fsum instances).
Returns:
Precision fsum (float).

See Also: Function fsum.

fsum1_ (*xs)

 

Precision floating point summation of a few arguments, 1-primed.

Arguments:
  • xs - Values to be added (scalar or Fsum instances), all positional.
Returns:
Precision fsum (float).

See Also: Function fsum

fsum_ (*xs)

 

Precision floating point summation of all positional arguments.

Arguments:
  • xs - Values to be added (scalar or Fsum instances), all positional.
Returns:
Precision fsum (float).

See Also: Function fsum.

ft2m (feet, usurvey=False, pied=False)

 

Convert International, US Survey or French feet to meter.

Arguments:
  • feet - Value in feet (scalar).
  • usurvey - Convert US Survey foot if (True).
  • pied - Convert French pied-du-Roi if (True), International foot otherwise.
Returns:
Value in meter (float).
Raises:
  • ValueError - Invalid feet.

furlong2m (furlongs)

 

Convert a furlong to meter.

Arguments:
  • furlongs - Value in furlongs (scalar).
Returns:
Value in meter (float).
Raises:
  • ValueError - Invalid furlongs.

geoidHeight2 (lat, lon, model=0, timeout=2.0)

 

Get the NAVD88 geoid height at an NAD83 location.

Arguments:
  • lat - Latitude (degrees).
  • lon - Longitude (degrees).
  • model - Optional, geoid model ID (int).
  • timeout - Optional, query timeout (seconds).
Returns:
An GeoidHeight2Tuple(height, model_name) or (None, "error") in case of errors.
Raises:
  • ValueError - Invalid timeout.

Note: The returned height is None if lat or lon is invalid or outside the Conterminous US (CONUS), if the model was invalid, if conversion failed or if the query timed out. The "error" is the HTTP-, IO-, SSL-, URL- or other -Error as a string (str).

See Also: NOAA National Geodetic Survey, Geoid, USGS10mElev.py, module geoids, classes GeoidG2012B, GeoidKarney and GeoidPGM.

gnomonic (lat0, lon0, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., exact=False, geodsolve=False, name='')

 

Return a GnomonicExact or (if Karney's geographiclib package is installed) a GnomonicKarney, otherwise a Gnomonic instance.

Arguments:
  • lat0 - Latitude of center point (degrees90).
  • lon0 - Longitude of center point (degrees180).
  • datum - Optional datum or ellipsoid (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple) or scalar earth radius (meter).
  • exact - Return a GnomonicExact instance.
  • geodsolve - Return an GnomonicGeodSolve instance.
  • name - Optional name for the projection (str).
Returns:
A GnomonicExact, GnomonicGeodSolve, GnomonicKarney or Gnomonic instance.
Raises:

grades (rad)

 

Convert radians to grades (aka gons or gradians).

Arguments:
  • rad - Angle (radians).
Returns:
Angle (grades).

grades2degrees (gon)

 

Convert grades (aka gons or gradians) to degrees.

Arguments:
  • gon - Angle (grades).
Returns:
Angle (degrees).

grades2radians (gon)

 

Convert grades (aka gons or gradians) to radians.

Arguments:
  • gon - Angle (grades).
Returns:
Angle (radians).

grades400 (rad)

 

Convert radians to grades (aka gons or gradians) and wrap [0..+400).

Arguments:
  • rad - Angle (radians).
Returns:
Angle, wrapped (grades).

halfs2 (str2)

 

Split a string in 2 halfs.

Arguments:
  • str2 - String to split (str).
Returns:
2-Tuple (_1st, _2nd) half (str).
Raises:
  • ValueError - Zero or odd len(str2).

hartzell (pov, los=None, earth=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., **LatLon_and_kwds)

 

Compute the intersection of a Line-Of-Sight from a Point-Of-View in space with the surface of the earth.

Arguments:
  • pov - Point-Of-View outside the earth (Cartesian, Ecef9Tuple or Vector3d).
  • los - Line-Of-Sight, direction to earth (Vector3d) or None to point to the earth' center.
  • earth - The earth model (Datum, Ellipsoid, Ellipsoid2, a_f2Tuple or scalar radius in meter).
  • LatLon_and_kwds - Optional LatLon class for the intersection point plus LatLon keyword arguments, include datum if different from earth.
Returns:
The earth intersection (Vector3d, Cartesian type of pov or LatLon).
Raises:
  • IntersectionError - Null pov or los vector, pov is inside the earth or los points outside the earth or points in an opposite direction.
  • TypeError - Invalid pov, los or earth.

See Also: Stephen Hartzell and function pygeodesy.tyr3d for los.

hausdorff_ (model, target, both=False, early=True, seed=None, units='', distance=None, point=<function _point at 0x7fd000186450>)

 

Compute the directed or symmetric Hausdorff distance between 2 sets of points with or without early breaking and random sampling.

Arguments:
  • model - First set of points (LatLon[], Numpy2LatLon[], Tuple2LatLon[] or other[]).
  • target - Second set of points (LatLon[], Numpy2LatLon[], Tuple2LatLon[] or other[]).
  • both - Return the directed (forward only) or the symmetric (combined forward and reverse) Hausdorff distance (bool).
  • early - Enable or disable early breaking (bool).
  • seed - Random sampling seed (any) or None, 0 or False for no random sampling.
  • units - Optional, the distance units (Unit or str).
  • distance - Callable returning the distance between a model and target point (signature (point1, point2)).
  • point - Callable returning the model or target point suitable for distance (signature (point)).
Returns:
A Hausdorff6Tuple(hd, i, j, mn, md, units).
Raises:
  • HausdorffError - Insufficient number of model or target points.
  • TypeError - If distance or point is not callable.

haversine (lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)

 

Compute the distance between two (spherical) points using the Haversine formula.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • radius - Mean earth radius, ellipsoid or datum (meter, Ellipsoid, Ellipsoid2, Datum or a_f2Tuple).
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Distance (meter, same units as radius).
Raises:
  • TypeError - Invalid radius.

See Also: Distance between two (spherical) points, functions cosineLaw, cosineAndoyerLambert, cosineForsytheAndoyerLambert, equirectangular, euclidean, flatLocal/hubeny, flatPolar, thomas and vincentys and methods Ellipsoid.distance2, LatLon.distanceTo* and LatLon.equirectangularTo.

Note: See note at function vincentys_.

haversine_ (phi2, phi1, lam21)

 

Compute the angular distance between two (spherical) points using the Haversine formula.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
Returns:
Angular distance (radians).

heightOf (angle, distance, radius=6371008.77141)

 

Determine the height above the (spherical) earth' surface after traveling along a straight line at a given tilt.

Arguments:
  • angle - Tilt angle above horizontal (degrees).
  • distance - Distance along the line (meter or same units as radius).
  • radius - Optional mean earth radius (meter).
Returns:
Height (meter, same units as distance and radius).
Raises:
  • ValueError - Invalid angle, distance or radius.

horizon (height, radius=6371008.77141, refraction=False)

 

Determine the distance to the horizon from a given altitude above the (spherical) earth.

Arguments:
  • height - Altitude (meter or same units as radius).
  • radius - Optional mean earth radius (meter).
  • refraction - Consider atmospheric refraction (bool).
Returns:
Distance (meter, same units as height and radius).
Raises:
  • ValueError - Invalid height or radius.

See Also: Distance to horizon.

hstr (height, prec=2, fmt='%+.*f', ints=False, m='')

 

Return a string for the height value.

Arguments:
  • height - Height value (float).
  • prec - The float precision, number of decimal digits (0..9). Trailing zero decimals are stripped if prec is positive, but kept for negative prec values.
  • fmt - Optional, float format (str).
  • ints - Optionally, remove the decimal dot for int values (bool).
  • m - Optional unit of the height (str).

hubeny (lat1, lon1, lat2, lon2, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., wrap=False)

 

Compute the distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • datum - Datum or ellipsoid to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Distance (meter, same units as the datum's ellipsoid axes).
Raises:
  • TypeError - Invalid datum.

Note: The meridional and prime_vertical radii of curvature are taken and scaled at the mean of both latitude.

See Also: Functions flatLocal_ or hubeny_, cosineLaw, flatPolar, cosineAndoyerLambert, cosineForsytheAndoyerLambert, equirectangular, euclidean, haversine, thomas, vincentys, method Ellipsoid.distance2 and local, flat earth approximation.

hubeny_ (phi2, phi1, lam21, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...)

 

Compute the angular distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
  • datum - Datum or ellipsoid to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
Returns:
Angular distance (radians).
Raises:
  • TypeError - Invalid datum.

Note: The meridional and prime_vertical radii of curvature are taken and scaled at the mean of both latitude.

See Also: Functions flatLocal or hubeny, cosineAndoyerLambert_, cosineForsytheAndoyerLambert_, cosineLaw_, flatPolar_, equirectangular_, euclidean_, haversine_, thomas_ and vincentys_ and local, flat earth approximation.

hypot1 (x)

 

Compute the norm sqrt(1 + x**2).

Arguments:
  • x - Argument (scalar).
Returns:
Norm (float).

hypot2 (x, y)

 

Compute the squared norm x**2 + y**2.

Arguments:
  • x - X argument (scalar).
  • y - Y argument (scalar).
Returns:
x**2 + y**2 (float).

hypot2_ (*xs)

 

Compute the squared norm sum(x**2 for x in xs).

Arguments:
  • xs - X arguments (scalars), all positional.
Returns:
Squared norm (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • ValueError - Invalid or no xs value.

See Also: Function hypot_.

hypot3 (x, y, z)

 

DEPRECATED, use function pygeodesy.hypot_.

Decorators:
  • @deprecated_function

hypot_ (*xs)

 

Compute the norm sqrt(sum(x**2 for x in xs)).

Similar to Python 3.8+ n-dimension math.hypot, but exceptions, nan and infinite values are handled differently.

Arguments:
  • xs - X arguments (scalars), all positional.
Returns:
Norm (float).
Raises:
  • OverflowError - Partial 2sum overflow.
  • ValueError - Invalid or no xs values.

Note: The Python 3.8+ Euclidian distance math.dist between 2 n-dimensional points p1 and p2 can be computed as hypot_(*((c1 - c2) for c1, c2 in zip(p1, p2))), provided p1 and p2 have the same, non-zero length n.

inStr (inst, *args, **kwds)

 

DEPRECATED, use function pygeodesy.instr.

Decorators:
  • @deprecated_function

instr (inst, *args, **kwds)

 

Return the string representation of an instantiation.

Arguments:
  • inst - The instance (any type).
  • args - Optional positional arguments.
  • kwds - Optional keyword arguments.
Returns:
Representation (str).

intersection3d3 (start1, end1, start2, end2, eps=2.22044604925e-16, useZ=True, **Vector_and_kwds)

 

Compute the intersection point of two lines, each defined by or through a start and end point (3-D).

Arguments:
  • start1 - Start point of the first line (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • end1 - End point of the first line (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • start2 - Start point of the second line (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • end2 - End point of the second line (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • eps - Tolerance for skew line distance and length (EPS).
  • useZ - If True, use the Z components, otherwise force z=INT0 (bool).
  • Vector_and_kwds - Optional class Vector=None to return the intersection points and optional, additional Vector keyword arguments, otherwise start1's (sub-)class.
Returns:
An Intersection3Tuple(point, outside1, outside2) with point an instance of Vector or start1's (sub-)class.
Raises:
  • IntersectionError - Invalid, skew, non-co-planar or otherwise non-intersecting lines.

intersections2 (center1, radius1, center2, radius2, sphere=True, **Vector_and_kwds)

 

Compute the intersection of two spheres or circles, each defined by a (3-D) center point and a radius.

Arguments:
  • center1 - Center of the first sphere or circle (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • radius1 - Radius of the first sphere or circle (same units as the center1 coordinates).
  • center2 - Center of the second sphere or circle (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • radius2 - Radius of the second sphere or circle (same units as the center1 and center2 coordinates).
  • sphere - If True compute the center and radius of the intersection of two spheres. If False, ignore the z-component and compute the intersection of two circles (bool).
  • Vector_and_kwds - Optional class Vector=None to return the intersection points and optional, additional Vector keyword arguments, otherwise center1's (sub-)class.
Returns:
If sphere is True, a 2-tuple of the center and radius of the intersection of the spheres. The radius is 0.0 for abutting spheres (and the center is aka radical center).

If sphere is False, a 2-tuple with the two intersection points of the circles. For abutting circles, both points are the same instance, aka radical center.

Raises:
  • IntersectionError - Concentric, invalid or non-intersecting spheres or circles.
  • TypeError - Invalid center1 or center2.
  • UnitError - Invalid radius1 or radius2.

See Also: Sphere-Sphere and Circle-Circle Intersection.

isNumpy2 (obj)

 

Check for an Numpy2LatLon points wrapper.

Arguments:
  • obj - The object (any type).
Returns:
True if obj is an Numpy2LatLon instance, False otherwise.

isPoints2 (obj)

 

Check for an LatLon2psxy points wrapper.

Arguments:
  • obj - The object (any type).
Returns:
True if obj is an LatLon2psxy instance, False otherwise.

isTuple2 (obj)

 

Check for an Tuple2LatLon points wrapper.

Arguments:
  • obj - The object (any).
Returns:
True if obj is an Tuple2LatLon instance, False otherwise.

isantipode (lat1, lon1, lat2, lon2, eps=2.22044604925e-16)

 

Check whether two points are antipodal, on diametrically opposite sides of the earth.

Arguments:
  • lat1 - Latitude of one point (degrees).
  • lon1 - Longitude of one point (degrees).
  • lat2 - Latitude of the other point (degrees).
  • lon2 - Longitude of the other point (degrees).
  • eps - Tolerance for near-equality (degrees).
Returns:
True if points are antipodal within the eps tolerance, False otherwise.

See Also: Geosphere.

isantipode_ (phi1, lam1, phi2, lam2, eps=2.22044604925e-16)

 

Check whether two points are antipodal, on diametrically opposite sides of the earth.

Arguments:
  • phi1 - Latitude of one point (radians).
  • lam1 - Longitude of one point (radians).
  • phi2 - Latitude of the other point (radians).
  • lam2 - Longitude of the other point (radians).
  • eps - Tolerance for near-equality (radians).
Returns:
True if points are antipodal within the eps tolerance, False otherwise.

See Also: Geosphere.

isbool (obj)

 

Check whether an object is boolean.

Arguments:
  • obj - The object (any type).
Returns:
True if obj is boolean, False otherwise.

isclass (obj)

 

Return True if obj is a class.

See Also: Python's inspect.isclass.

isclockwise (points, adjust=False, wrap=True)

 

Determine the direction of a path or polygon.

Arguments:
  • points - The path or polygon points (LatLon[]).
  • adjust - Adjust the wrapped, unrolled longitudinal delta by the cosine of the mean latitude (bool).
  • wrap - Wrap lat-, wrap and unroll longitudes (bool).
Returns:
True if points are clockwise, False otherwise.
Raises:
  • PointsError - Insufficient number of points
  • TypeError - Some points are not LatLon.
  • ValueError - The points enclose a pole or zero area.

Example:

>>> f = LatLon(45,1), LatLon(45,2), LatLon(46,2), LatLon(46,1)
>>> isclockwise(f)  # False
>>> isclockwise(reversed(f))  # True

iscolinearWith (point, point1, point2, eps=2.22044604925e-16, useZ=True)

 

Check whether a point is colinear with two other (2- or 3-D) points.

Arguments:
  • point - The point (Vector3d, Vector3Tuple or Vector4Tuple).
  • point1 - First point (Vector3d, Vector3Tuple or Vector4Tuple).
  • point2 - Second point (Vector3d, Vector3Tuple or Vector4Tuple).
  • eps - Tolerance (scalar), same units as x, y and z.
  • useZ - If True, use the Z components, otherwise force z=INT0 (bool).
Returns:
True if point is colinear point1 and point2, False otherwise.
Raises:
  • TypeError - Invalid point, point1 or point2.

See Also: Function nearestOn.

iscomplex (obj)

 

Check whether an object is complex.

Arguments:
  • obj - The object (any type).
Returns:
True if obj is complex, False otherwise.

isconvex (points, adjust=False, wrap=True)

 

Determine whether a polygon is convex.

Arguments:
  • points - The polygon points (LatLon[]).
  • adjust - Adjust the wrapped, unrolled longitudinal delta by the cosine of the mean latitude (bool).
  • wrap - Wrap lat-, wrap and unroll longitudes (bool).
Returns:
True if points are convex, False otherwise.
Raises:
  • CrossError - Some points are colinear.
  • PointsError - Insufficient number of points
  • TypeError - Some points are not LatLon.

Example:

>>> t = LatLon(45,1), LatLon(46,1), LatLon(46,2)
>>> isconvex(t)  # True
>>> f = LatLon(45,1), LatLon(46,2), LatLon(45,2), LatLon(46,1)
>>> isconvex(f)  # False

isconvex_ (points, adjust=False, wrap=True)

 

Determine whether a polygon is convex and clockwise.

Arguments:
  • points - The polygon points (LatLon[]).
  • adjust - Adjust the wrapped, unrolled longitudinal delta by the cosine of the mean latitude (bool).
  • wrap - Wrap lat-, wrap and unroll longitudes (bool).
Returns:
+1 if points are convex clockwise, -1 for convex counter-clockwise points, 0 otherwise.
Raises:
  • CrossError - Some points are colinear.
  • PointsError - Insufficient number of points
  • TypeError - Some points are not LatLon.

Example:

>>> t = LatLon(45,1), LatLon(46,1), LatLon(46,2)
>>> isconvex_(t)  # +1
>>> f = LatLon(45,1), LatLon(46,2), LatLon(45,2), LatLon(46,1)
>>> isconvex_(f)  # 0

isenclosedBy (point, points, wrap=False)

 

Determine whether a point is enclosed by a polygon.

Arguments:
  • point - The point (LatLon or 2-tuple (lat, lon)).
  • points - The polygon points (LatLon[]).
  • wrap - Wrap lat-, wrap and unroll longitudes (bool).
Returns:
True if point is inside the polygon, False otherwise.
Raises:
  • PointsError - Insufficient number of points
  • TypeError - Some points are not LatLon.
  • ValueError - Invalid point, lat- or longitude.

See Also: Functions pygeodesy.isconvex, pygeodesy.isenclosedBy and pygeodesy.ispolar especially if the points may enclose a pole or wrap around the earth longitudinally, methods sphericalNvector.LatLon.isenclosedBy, sphericalTrigonometry.LatLon.isenclosedBy and MultiDop GeogContainPt (Shapiro et al. 2009, JTECH and Potvin et al. 2012, JTECH).

isenclosedby (point, points, wrap=False)

 

DEPRECATED, use function pygeodesy.isenclosedBy.

Decorators:
  • @deprecated_function

isfinite (obj)

 

Check for non-finite scalar value.

Arguments:
  • obj - Value (scalar).
Returns:
False if obj is INF, NINF or NAN, True otherwise.
Raises:
  • TypeError - Non-scalar obj.

isint (obj, both=False)

 

Check for int type or an integer float value.

Arguments:
  • obj - The object (any type).
  • both - If true, check float and Fsum type and value (bool).
Returns:
True if obj is int or an integer float or Fsum, False otherwise.

Note: isint(True) or isint(False) returns False (and no longer True).

isint0 (obj, both=False)

 

Check for INT0 or int(0) value.

Arguments:
  • obj - The object (any type).
  • both - If true, also check float(0) (bool).
Returns:
True if obj is INT0, int(0) or float(0), False otherwise.

isnear0 (x, eps0=4.93038065763e-32)

 

Is x near zero?

Arguments:
  • x - Value (scalar).
  • eps0 - Near-zero (EPS0).
Returns:
True if abs(x) < eps0, False otherwise.

See Also: Function isnon0.

isnear1 (x, eps0=4.93038065763e-32)

 

Is x near one?

Arguments:
  • x - Value (scalar).
  • eps0 - Near-zero (EPS0).
Returns:
isnear0(x - 1).

See Also: Function isnear0.

isneg0 (x)

 

Check for NEG0, negative 0.0.

Arguments:
  • x - Value (scalar).
Returns:
True if x is NEG0 or -0.0, False otherwise.

isninf (x)

 

Check for NINF, negative INF.

Arguments:
  • x - Value (scalar).
Returns:
True if x is NINF or -inf, False otherwise.

isnon0 (x, eps0=4.93038065763e-32)

 

Is x non-zero?

Arguments:
  • x - Value (scalar).
  • eps0 - Near-zero (EPS0).
Returns:
True if abs(x) > eps0, False otherwise.

See Also: Function isnear0.

isodd (x)

 

Is x odd?

Arguments:
  • x - Value (scalar).
Returns:
True if x is odd, False otherwise.

ispolar (points, wrap=False)

 

Check whether a polygon encloses a pole.

Arguments:
  • points - The polygon points (LatLon[]).
  • wrap - Wrap and unroll longitudes (bool).
Returns:
True if the polygon encloses a pole, False otherwise.
Raises:
  • PointsError - Insufficient number of points
  • TypeError - Some points are not LatLon or don't have bearingTo2, initialBearingTo and finalBearingTo methods.

isscalar (obj)

 

Check for scalar types.

Arguments:
  • obj - The object (any type).
Returns:
True if obj is scalar, False otherwise.

issequence (obj, *excls)

 

Check for sequence types.

Arguments:
  • obj - The object (any type).
  • excls - Classes to exclude (type), all positional.
Returns:
True if obj is a sequence, False otherwise.

Note: Excluding tuple implies excluding namedtuple.

isstr (obj)

 

Check for string types.

Arguments:
  • obj - The object (any type).
Returns:
True if obj is str, False otherwise.

issubclassof (Sub, *Supers)

 

Check whether a class is a sub-class of some other class(es).

Arguments:
  • Sub - The sub-class (class).
  • Supers - One or more C(super) classes (class).
Returns:
True if Sub is a sub-class of any Supers, False if not (bool) or None if Sub is not a class or if no Supers are given or none of those are a class.

iterNumpy2 (obj)

 

Iterate over Numpy2 wrappers or other sequences exceeding the threshold.

Arguments:
  • obj - Points array, list, sequence, set, etc. (any).
Returns:
True do, False don't iterate.

iterNumpy2over (n=None)

 

Get or set the iterNumpy2 threshold.

Arguments:
  • n - Optional, new threshold (int).
Returns:
Previous threshold (int).
Raises:
  • ValueError - Invalid n.

joined (*words, **sep)

 

DEPRECATED, use NN(...), NN.join_ or sep.join.

Decorators:
  • @deprecated_function

joined_ (*words, **sep)

 

DEPRECATED, use _SPACE_(...), _SPACE_.join_ or sep.join, sep=" ".

Decorators:
  • @deprecated_function

latDMS (deg, form='dms', prec=2, sep='', **s_D_M_S)

 

Convert latitude to a string, optionally suffixed with N or S.

Arguments:
Returns:
Degrees in the specified form (str).

See Also: Functions pygeodesy.toDMS and pygeodesy.lonDMS.

JS name: toLat.

latlon2n_xyz (lat, lon, name='')

 

Convert lat-, longitude to n-vector (normal to the earth's surface) X, Y and Z components.

Arguments:
  • lat - Latitude (degrees).
  • lon - Longitude (degrees).
  • name - Optional name (str).
Returns:
A Vector3Tuple(x, y, z).

See Also: Function philam2n_xyz.

Note: These are n-vector x, y and z components, NOT geocentric ECEF x, y and z coordinates!

latlonDMS (lls, form='dms', prec=None, sep=None, **s_D_M_S)

 

Convert one or more LatLon instances to strings.

Arguments:
Returns:
A str or tuple if sep=None or NN and if lls is a list, sequence, tuple, etc.

latlonDMS_ (*lls, **form_prec_sep_s_D_M_S)

 

Convert one or more LatLon instances to strings.

Arguments:
  • lls - The instances, all positional arguments (LatLons).
  • form_prec_sep_s_D_M_S - Optional format, precision, separator, s_D, s_M and s_S keyword arguments, see function latlonDMS.
Returns:
A str or tuple if sep=None or NN and if more than one lls is given.

See Also: Function pygeodesy.latlonDMS.

len2 (items)

 

Make built-in function len work for generators, iterators, etc. since those can only be started exactly once.

Arguments:
  • items - Generator, iterator, list, range, tuple, etc.
Returns:
2-Tuple (n, items) of the number of items (int) and the items (list or tuple).

limiterrors (raiser=None)

 

Get/set the throwing of LimitErrors.

Arguments:
  • raiser - Choose True to raise or False to ignore LimitError exceptions. Use None to leave the setting unchanged.
Returns:
Previous setting (bool).

lonDMS (deg, form='dms', prec=2, sep='', **s_D_M_S)

 

Convert longitude to a string, optionally suffixed with E or W.

Arguments:
Returns:
Degrees in the specified form (str).

See Also: Functions pygeodesy.toDMS and pygeodesy.latDMS.

JS name: toLon.

luneOf (lon1, lon2, closed=False, LatLon=<class 'pygeodesy.points.LatLon_'>, **LatLon_kwds)

 

Generate an ellipsoidal or spherical lune-shaped path or polygon.

Arguments:
  • lon1 - Left longitude (degrees90).
  • lon2 - Right longitude (degrees90).
  • closed - Optionally, close the path (bool).
  • LatLon - Class to use (LatLon_).
  • LatLon_kwds - Optional, additional LatLon keyword arguments.
Returns:
A tuple of 4 or 5 LatLon instances outlining the lune shape.

m2NM (meter)

 

Convert meter to nautical miles (NM).

Arguments:
  • meter - Value in meter (scalar).
Returns:
Value in NM (float).
Raises:
  • ValueError - Invalid meter.

m2SM (meter)

 

Convert meter to statute miles (SM).

Arguments:
  • meter - Value in meter (scalar).
Returns:
Value in SM (float).
Raises:
  • ValueError - Invalid meter.

m2chain (meter)

 

Convert meter to UK chains.

Arguments:
  • meter - Value in meter (scalar).
Returns:
Value in chains (float).
Raises:
  • ValueError - Invalid meter.

m2degrees (distance, radius=6371008.77141, lat=0)

 

Convert a distance to an angle along the equator or along the parallel at an other (geodetic) latitude.

Arguments:
  • distance - Distance (meter, same units as radius).
  • radius - Mean earth radius, ellipsoid or datum (meter, an Ellipsoid, Ellipsoid2, Datum or a_f2Tuple).
  • lat - Parallel latitude (degrees90, str).
Returns:
Angle (degrees) or INF for near-polar lat.
Raises:
  • RangeError - Latitude lat outside valid range and pygeodesy.rangerrors set to True.
  • TypeError - Invalid radius.
  • ValueError - Invalid distance, radius or lat.

See Also: Function m2radians and degrees2m.

m2fathom (meter)

 

Convert meter to Imperial fathoms.

Arguments:
  • meter - Value in meter (scalar).
Returns:
Value in fathoms (float).
Raises:
  • ValueError - Invalid meter.

See Also: Function m2toise, Fathom and Klafter.

m2ft (meter, usurvey=False, pied=False)

 

Convert meter to International, US Survey or French feet (ft).

Arguments:
  • meter - Value in meter (scalar).
  • usurvey - Convert to US Survey foot if (True).
  • pied - Convert to French pied-du-Roi if (True), International foot otherwise.
Returns:
Value in feet (float).
Raises:
  • ValueError - Invalid meter.

m2furlong (meter)

 

Convert meter to furlongs.

Arguments:
  • meter - Value in meter (scalar).
Returns:
Value in furlongs (float).
Raises:
  • ValueError - Invalid meter.

m2km (meter)

 

Convert meter to kilo meter (km).

Arguments:
  • meter - Value in meter (scalar).
Returns:
Value in km (float).
Raises:
  • ValueError - Invalid meter.

m2radians (distance, radius=6371008.77141, lat=0)

 

Convert a distance to an angle along the equator or along the parallel at an other (geodetic) latitude.

Arguments:
  • distance - Distance (meter, same units as radius).
  • radius - Mean earth radius, ellipsoid or datum (meter, an Ellipsoid, Ellipsoid2, Datum or a_f2Tuple).
  • lat - Parallel latitude (degrees90, str).
Returns:
Angle (radians) or INF for near-polar lat.
Raises:
  • RangeError - Latitude lat outside valid range and pygeodesy.rangerrors set to True.
  • TypeError - Invalid radius.
  • ValueError - Invalid distance, radius or lat.

See Also: Function m2degrees and radians2m.

m2toise (meter)

 

Convert meter to French toises.

Arguments:
  • meter - Value in meter (scalar).
Returns:
Value in toises (float).
Raises:
  • ValueError - Invalid meter.

See Also: Function m2fathom.

m2yard (meter)

 

Convert meter to UK yards.

Arguments:
  • meter - Value in meter (scalar).
Returns:
Value in yards (float).
Raises:
  • ValueError - Invalid meter.

machine()

 

Return standard platform.machine, but distinguishing Intel from Intel emulation on Apple Silicon (on macOS only).

Returns:
Machine 'arm64' for Apple Silicon native, 'x86_64' for Intel native, Intel "arm64_x86_64" for Intel emulation, etc. (str with commas replaced by underscores).

map1 (fun1, *xs)

 

Apply each argument to a single-argument function and return a tuple of results.

Arguments:
  • fun1 - 1-Arg function to apply (callable).
  • xs - Arguments to apply (any positional).
Returns:
Function results (tuple).

map2 (func, *xs)

 

Apply arguments to a function and return a tuple of results.

Unlike Python 2's built-in map, Python 3+ map returns a map object, an iterator-like object which generates the results only once. Converting the map object to a tuple maintains the Python 2 behavior.

Arguments:
  • func - Function to apply (callable).
  • xs - Arguments to apply (list, tuple, ...).
Returns:
Function results (tuple).

meeus2 (point1, point2, point3, circum=False, useZ=True)

 

Return the radius and Meeus' Type of the smallest circle through or containing three (2- or 3-D) points.

Arguments:
  • point1 - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • point2 - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • point3 - Third point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • circum - If True return the non-zero circumradius always, ignoring the Meeus' Type I case (bool).
  • useZ - If True, use the Z components, otherwise force z=INT0 (bool).
Returns:
Meeus2Tuple(radius, Type).
Raises:
  • IntersectionError - Near-coincident or -colinear points, iff circum=True.
  • TypeError - Invalid point1, point2 or point3.

modulename (clas, prefixed=None)

 

Return the class name optionally prefixed with the module name.

Arguments:
  • clas - The class (any class).
  • prefixed - Include the module name (bool), see function classnaming.
Returns:
The class's [module.]class name (str).

n2e2 (n)

 

Return e2, the 1st eccentricity squared for a given 3rd flattening.

Arguments:
  • n - The 3rd flattening (-1 <= scalar < 1).
Returns:
The signed, (1st) eccentricity squared (float or NINF), 4 * n / (1 + n)**2.

Note: The result is positive for oblate, negative for prolate or 0 for near-spherical ellipsoids.

See Also: Flattening.

n2f (n)

 

Return f, the flattening for a given 3rd flattening.

Arguments:
  • n - The 3rd flattening (-1 <= scalar < 1).
Returns:
The flattening (float or NINF), 2 * n / (1 + n).

n2f_ (n)

 

Return f_, the inverse flattening for a given 3rd flattening.

Arguments:
  • n - The 3rd flattening (-1 <= scalar < 1).
Returns:
The inverse flattening (float or 0), 1 / f.

See Also: n2f and f2f_.

n_xyz2latlon (x, y, z, name='')

 

Convert n-vector components to lat- and longitude in degrees.

Arguments:
  • x - X component (scalar).
  • y - Y component (scalar).
  • z - Z component (scalar).
  • name - Optional name (str).
Returns:
A LatLon2Tuple(lat, lon).

See Also: Function n_xyz2philam.

n_xyz2philam (x, y, z, name='')

 

Convert n-vector components to lat- and longitude in radians.

Arguments:
  • x - X component (scalar).
  • y - Y component (scalar).
  • z - Z component (scalar).
  • name - Optional name (str).
Returns:
A PhiLam2Tuple(phi, lam).

See Also: Function n_xyz2latlon.

nameof (inst)

 

Get the name of an instance.

Arguments:
  • inst - The object (any type).
Returns:
The instance' name (str) or "".

nearestOn (point, point1, point2, within=True, useZ=True, Vector=None, **Vector_kwds)

 

Locate the point between two points closest to a reference (2- or 3-D).

Arguments:
  • point - Reference point (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • point1 - Start point (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • point2 - End point (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • within - If True return the closest point between both given points, otherwise the closest point on the extended line through both points (bool).
  • useZ - If True, use the Z components, otherwise force z=INT0 (bool).
  • Vector - Class to return closest point (Cartesian, Vector3d or Vector3Tuple) or None.
  • Vector_kwds - Optional, additional Vector keyword arguments, ignored if Vector is None.
Returns:
Closest point, either point1 or point2 or an instance of the point's (sub-)class or Vector if not None.
Raises:
  • TypeError - Invalid point, point1 or point2.

See Also: 3-D Point-Line Distance, Cartesian and LatLon methods nearestOn, method sphericalTrigonometry.LatLon.nearestOn3 and function sphericalTrigonometry.nearestOn3.

nearestOn3 (point, points, closed=False, wrap=False, **options)

 

DEPRECATED, use function pygeodesy.nearestOn5.

Returns:
3-Tuple (lat, lon, distance)
Decorators:
  • @deprecated_function

nearestOn4 (point, points, closed=False, wrap=False, **options)

 

DEPRECATED, use function pygeodesy.nearestOn5.

Returns:
4-Tuple (lat, lon, distance, angle)
Decorators:
  • @deprecated_function

nearestOn5 (point, points, closed=False, wrap=False, LatLon=None, **options)

 

Locate the point on a path or polygon closest to a reference point.

The closest point is either on and within the extent of a polygon edge or the nearest of that edge's end points.

Arguments:
  • point - Reference point (LatLon).
  • points - The path or polygon points (LatLon[]).
  • closed - Optionally, close the path or polygon (bool).
  • wrap - Wrap and pygeodesy.unroll180 longitudes and longitudinal delta (bool) in function pygeodesy.equirectangular_.
  • LatLon - Optional class to return the closest point (LatLon) or None.
  • options - Other keyword arguments for function pygeodesy.equirectangular_.
Returns:
A NearestOn3Tuple(closest, distance, angle) with the {closest} point (LatLon) or if LatLon is None, a NearestOn5Tuple(lat, lon, distance, angle, height). The distance is the pygeodesy.equirectangular distance between the closest and reference point in degrees. The angle from the reference point to the closest is in compass degrees360, like function pygeodesy.compassAngle.
Raises:

Note: Distances are approximated using function pygeodesy.equirectangular_, subject to the supplied options. Method LatLon.nearestOn6 measures distances more accurately.

See Also: Function pygeodesy.nearestOn6 for cartesian points. Use function pygeodesy.degrees2m to convert degrees to meter.

nearestOn6 (point, points, closed=False, useZ=True, **Vector_and_kwds)

 

Locate the point on a path or polygon closest to a reference point.

The closest point is either on and within the extent of a polygon edge or the nearest of that edge's end points.

Arguments:
  • point - Reference point (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • points - The path or polygon points (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple[]).
  • closed - Optionally, close the path or polygon (bool).
  • useZ - If True, use the Z components, otherwise force z=INT0 (bool).
  • Vector_and_kwds - Optional class Vector=None to return the closest point and optional, additional Vector keyword arguments, otherwise point's (sub-)class.
Returns:
A NearestOn6Tuple(closest, distance, fi, j, start, end) with the closest, the start and the end point each an instance of the Vector keyword argument of if {Vector=None} or not specified, an instance of the point's (sub-)class.
Raises:
  • PointsError - Insufficient number of points
  • TypeError - Non-cartesian point and points.

Note: Distances measured with method Vector3d.equirectangular.

See Also: Method LatLon.nearestOn6 or function nearestOn5 for geodetic points.

neg (x)

 

Negate x unless zero or NEG0.

Returns:
-x if x else 0.0.

neg_ (*xs)

 

Negate all of xs with neg.

Returns:
A tuple(neg(x) for x in xs).

norm2 (x, y)

 

Normalize a 2-dimensional vector.

Arguments:
  • x - X component (scalar).
  • y - Y component (scalar).
Returns:
2-Tuple (x, y), normalized.
Raises:
  • ValueError - Invalid x or y or zero norm.

normDMS (strDMS, norm=None, **s_D_M_S)

 

Normalize all degrees, minutes and seconds (DMS) symbols in a string to the default symbols S_DEG, S_MIN, S_SEC.

Arguments:
  • strDMS - Original DMS string (str).
  • norm - Optional replacement symbol (str) or None for the default DMS symbols). Use norm="" to remove all DMS symbols.
  • s_D_M_S - Optional, alternate DMS symbols s_D=str, s_M=str, s_S=str and/or s_R=str for radians, each to be replaced by norm.
Returns:
Normalized DMS (str).

norm_ (*xs)

 

Normalize all n-dimensional vector components.

Arguments:
  • xs - Components (scalars), all positional.
Returns:
Yield each component, normalized.
Raises:
  • ValueError - Invalid or insufficent xs or zero norm.

notImplemented (inst, *args, **kwds)

 

Raise a NotImplementedError for a missing method or property.

Arguments:
  • inst - Instance (any).
  • args - Method or property positional arguments (any types).
  • kwds - Method or property keyword arguments (any types).

notOverloaded (inst, *args, **kwds)

 

Raise an AssertionError for a method or property not overloaded.

Arguments:
  • inst - Instance (any).
  • args - Method or property positional arguments (any types).
  • kwds - Method or property keyword arguments (any types).

opposing (bearing1, bearing2, margin=None)

 

Compare the direction of two bearings given in degrees.

Arguments:
  • bearing1 - First bearing (compass degrees).
  • bearing2 - Second bearing (compass degrees).
  • margin - Optional, interior angle bracket (degrees), default 90.
Returns:
True if both bearings point in opposite, False if in similar or None if in perpendicular directions.

See Also: Function opposing_.

opposing_ (radians1, radians2, margin=None)

 

Compare the direction of two bearings given in radians.

Arguments:
  • radians1 - First bearing (radians).
  • radians2 - Second bearing (radians).
  • margin - Optional, interior angle bracket (radians), default PI_2.
Returns:
True if both bearings point in opposite, False if in similar or None if in perpendicular directions.

See Also: Function opposing.

pairs (items, prec=6, fmt='F', ints=False, sep='=')

 

Convert items to name=value strings, with floats handled like fstr.

Arguments:
  • items - Name-value pairs (dict or 2-{tuple}s of any types).
  • prec - The float precision, number of decimal digits (0..9). Trailing zero decimals are stripped if prec is positive, but kept for negative prec values.
  • fmt - Optional, float format (str).
  • ints - Optionally, remove the decimal dot for int values (bool).
  • sep - Separator joining names and values (str).
Returns:
A tuple(sep.join(t) for t in items)) of strs.

parse3d (str3d, sep=',', Vector=<class 'pygeodesy.vector3d.Vector3d'>, **Vector_kwds)

 

Parse an "x, y, z" string.

Arguments:
  • str3d - X, y and z values (str).
  • sep - Optional separator (str).
  • Vector - Optional class (Vector3d).
  • Vector_kwds - Optional Vector keyword arguments, ignored if Vector is None.
Returns:
A Vector instance or if Vector is None, a named Vector3Tuple(x, y, z).
Raises:

parse3llh (strllh, height=0, sep=',', clipLat=90, clipLon=180, **s_D_M_S)

 

Parse a string "lat lon [h]" representing lat-, longitude in degrees and optional height in meter.

The lat- and longitude value must be separated by a separator character. If height is present it must follow, separated by another separator.

The lat- and longitude values may be swapped, provided at least one ends with the proper compass point.

Arguments:
  • strllh - Latitude, longitude[, height] (str, ...).
  • height - Optional, default height (meter) or None.
  • sep - Optional separator between "lat lon [h]" (str).
  • clipLat - Limit latitude to range -/+clipLat (degrees).
  • clipLon - Limit longitude to range -/+clipLon (degrees).
  • s_D_M_S - Optional, alternate symbol for degrees s_D=str, minutes, s_M=str and/or seconds s_S=str.
Returns:
A LatLon3Tuple(lat, lon, height) in degrees, degrees and float.
Raises:

Note: See the Notes at function parseDMS.

See Also: Functions pygeodesy.parseDDDMMSS, pygeodesy.parseDMS, pygeodesy.parseDMS2 and pygeodesy.toDMS.

Example:

>>> parse3llh('000°00′05.31″W, 51° 28′ 40.12″ N')
(51.4778°N, 000.0015°W, 0)

parseDDDMMSS (strDDDMMSS, suffix='NSEW', sep='', clip=0, sexagecimal=False)

 

Parse a lat- or longitude represention forms as [D]DDMMSS in degrees.

Arguments:
  • strDDDMMSS - Degrees in any of several forms (str) and types (float, int, other).
  • suffix - Optional, valid compass points (str, tuple).
  • sep - Optional separator between "[D]DD", "MM" and "SS" (S_SEP).
  • clip - Optionally, limit value to range -/+clip (degrees).
  • sexagecimal - If True, convert "D.MMSS" or float(D.MMSS) to base-60 "MM" and "SS" digits. See forms F_D60, F_D60_ and F_D60__.
Returns:
Degrees (float).
Raises:
  • ParseError - Invalid strDDDMMSS or clip or the form of strDDDMMSS is incompatible with the suffixed or suffix compass point.
  • RangeError - Value of strDDDMMSS outside the valid -/+clip range and pygeodesy.rangerrors set to True.
Notes:
  • Type str values "[D]DD", "[D]DDMM", "[D]DDMMSS" and "[D]DD.MMSS" for strDDDMMSS are parsed properly only if either unsigned and suffixed with a valid, compatible, cardinal compassPoint or signed or unsigned, unsuffixed and with keyword argument suffix="NS", suffix="EW" or a compatible compassPoint.
  • Unlike function parseDMS, type float, int and other non-str strDDDMMSS values are interpreted as form [D]DDMMSS or [D]DD.MMSS. For example, int(1230) is returned as 12.5 and not 1230.0 degrees. However, int(345) is considered form "DDD" 345 and not "DDMM" 0345, unless suffix specifies the compass point. Also, float(15.0523) is returned as 15.0523 decimal degrees and not 15°5′23″ sexagecimal. To consider the latter, use float(15.0523) or "15.0523" and specify the keyword argument sexagecimal=True.

See Also: Functions pygeodesy.parseDMS, pygeodesy.parseDMS2 and pygeodesy.parse3llh.

parseDMS (strDMS, suffix='NSEW', sep='', clip=0, **s_D_M_S)

 

Parse a lat- or longitude representation in degrees.

This is very flexible on formats, allowing signed decimal degrees, degrees and minutes or degrees minutes and seconds optionally suffixed by a cardinal compass point.

A variety of symbols, separators and suffixes are accepted, for example "3°37′09″W". Minutes and seconds may be omitted.

Arguments:
  • strDMS - Degrees in any of several forms (str) and types (float, int, other).
  • suffix - Optional, valid compass points (str, tuple).
  • sep - Optional separator between deg°, min′ and sec″ ('').
  • clip - Optionally, limit value to range -/+clip (degrees).
  • s_D_M_S - Optional, alternate symbol for degrees s_D=str, minutes, s_M=str and/or seconds s_S=str.
Returns:
Degrees (float).
Raises:

Note: Unlike function parseDDDMMSS, type float, int and other non-str strDMS values are considered decimal (and not sexagecimal) degrees. For example, int(1230) is returned as 1230.0 and not as 12.5 degrees and float(345) as 345.0 and not as 3.75 degrees!

See Also: Functions pygeodesy.parseDDDMMSS, pygeodesy.parseDMS2, pygeodesy.parse3llh and pygeodesy.toDMS.

parseDMS2 (strLat, strLon, sep='', clipLat=90, clipLon=180, **s_D_M_S)

 

Parse a lat- and a longitude representions "lat, lon" in degrees.

Arguments:
  • strLat - Latitude in any of several forms (str or degrees).
  • strLon - Longitude in any of several forms (str or degrees).
  • sep - Optional separator between deg°, min′ and sec″ ('').
  • clipLat - Limit latitude to range -/+clipLat (degrees).
  • clipLon - Limit longitude to range -/+clipLon (degrees).
  • s_D_M_S - Optional, alternate symbol for degrees s_D=str, minutes, s_M=str and/or seconds s_S=str.
Returns:
A LatLon2Tuple(lat, lon) in degrees.
Raises:

Note: See the Notes at function parseDMS.

See Also: Functions pygeodesy.parseDDDMMSS, pygeodesy.parseDMS, pygeodesy.parse3llh and pygeodesy.toDMS.

parseETM5 (strUTM, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Etm=<class 'pygeodesy.etm.Etm'>, falsed=True, name='')

 

Parse a string representing a UTM coordinate, consisting of "zone[band] hemisphere easting northing".

Arguments:
  • strUTM - A UTM coordinate (str).
  • datum - Optional datum to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
  • Etm - Optional class to return the UTM coordinate (Etm) or None.
  • falsed - Both easting and northing are falsed (bool).
  • name - Optional Etm name (str).
Returns:
The UTM coordinate (Etm) or if Etm is None, a UtmUps5Tuple(zone, hemipole, easting, northing, band). The hemipole is the hemisphere 'N'|'S'.
Raises:
  • ETMError - Invalid strUTM.
  • TypeError - Invalid or near-spherical datum.

Example:

>>> u = parseETM5('31 N 448251 5411932')
>>> u.toRepr()  # [Z:31, H:N, E:448251, N:5411932]
>>> u = parseETM5('31 N 448251.8 5411932.7')
>>> u.toStr()  # 31 N 448252 5411933

parseMGRS (strMGRS, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Mgrs=<class 'pygeodesy.mgrs.Mgrs'>, name='')

 

Parse a string representing a MGRS grid reference, consisting of "zoneBand, grid, easting, northing".

Arguments:
  • strMGRS - MGRS grid reference (str).
  • datum - Optional datum to use (Datum).
  • Mgrs - Optional class to return the MGRS grid reference (Mgrs) or None.
  • name - Optional Mgrs name (str).
Returns:
The MGRS grid reference as Mgrs or if Mgrs is None as an Mgrs4Tuple(zone, digraph, easting, northing).
Raises:

Example:

>>> m = parseMGRS('31U DQ 48251 11932')
>>> str(m)  # 31U DQ 48251 11932
>>> m = parseMGRS('31UDQ4825111932')
>>> repr(m)  # [Z:31U, G:DQ, E:48251, N:11932]
>>> m = mgrs.parseMGRS('42SXD0970538646')
>>> str(m)  # 42S XD 09705 38646
>>> m = mgrs.parseMGRS('42SXD9738')  # Km
>>> str(m)  # 42S XD 97000 38000

parseOSGR (strOSGR, Osgr=<class 'pygeodesy.osgr.Osgr'>, name='')

 

Parse a string representing an OSGR grid reference, consisting of "[grid] easting northing".

Accepts standard OS Grid References like 'SU 387 148', with or without whitespace separators, from 2- up to 10-digit references (1 m × 1 m square), or all-numeric, comma-separated references in meters, for example '438700,114800'.

Arguments:
  • strOSGR - An OSGR coordinate (str).
  • Osgr - Optional class to return the OSGR coordinate (Osgr) or None.
  • name - Optional Osgr name (str).
Returns:
The OSGR coordinate (Osgr) or an EasNor2Tuple(easting, northing) if Osgr is None.
Raises:

Example:

>>> g = parseOSGR('TG 51409 13177')
>>> str(g)  # TG 51409 13177
>>> g = parseOSGR('TG5140913177')
>>> str(g)  # TG 51409 13177
>>> g = parseOSGR('TG51409 13177')
>>> str(g)  # TG 51409 13177
>>> g = parseOSGR('651409,313177')
>>> str(g)  # TG 51409 13177
>>> g.toStr(prec=0)  # 651409,313177

parseRad (strRad, suffix='NSEW', clip=0)

 

Parse a string representing angle in radians.

Arguments:
  • strRad - Degrees in any of several forms (str or radians).
  • suffix - Optional, valid compass points (str, tuple).
  • clip - Optionally, limit value to range -/+clip (radians).
Returns:
Radians (float).
Raises:

parseUPS5 (strUPS, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Ups=<class 'pygeodesy.ups.Ups'>, falsed=True, name='')

 

Parse a string representing a UPS coordinate, consisting of "[zone][band] pole easting northing" where zone is pseudo zone "00"|"0"|"" and band is 'A'|'B'|'Y'|'Z'|''.

Arguments:
  • strUPS - A UPS coordinate (str).
  • datum - Optional datum to use (Datum).
  • Ups - Optional class to return the UPS coordinate (Ups) or None.
  • falsed - Both easting and northing are falsed (bool).
  • name - Optional Ups name (str).
Returns:
The UPS coordinate (Ups) or a UtmUps5Tuple(zone, hemipole, easting, northing, band) if Ups is None. The hemipole is the 'N'|'S' pole, the UPS projection top/center.
Raises:

parseUTM (strUTM, datum=_UTM, Utm=_UTM, name='')

 

DEPRECATED, use function parseUTM5.

Returns:
The UTM coordinate (Utm) or 4-tuple (zone, hemisphere, easting, northing) if Utm is None.
Decorators:
  • @deprecated_function

parseUTM5 (strUTM, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Utm=<class 'pygeodesy.utm.Utm'>, falsed=True, name='')

 

Parse a string representing a UTM coordinate, consisting of "zone[band] hemisphere easting northing".

Arguments:
  • strUTM - A UTM coordinate (str).
  • datum - Optional datum to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
  • Utm - Optional class to return the UTM coordinate (Utm) or None.
  • falsed - Both easting and northing are falsed (bool).
  • name - Optional Utm name (str).
Returns:
The UTM coordinate (Utm) or if Utm is None, a UtmUps5Tuple(zone, hemipole, easting, northing, band). The hemipole is the 'N'|'S' hemisphere.
Raises:
  • UTMError - Invalid strUTM.
  • TypeError - Invalid datum.

Example:

>>> u = parseUTM5('31 N 448251 5411932')
>>> u.toRepr()  # [Z:31, H:N, E:448251, N:5411932]
>>> u = parseUTM5('31 N 448251.8 5411932.7')
>>> u.toStr()  # 31 N 448252 5411933

parseUTMUPS5 (strUTMUPS, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Utm=<class 'pygeodesy.utm.Utm'>, Ups=<class 'pygeodesy.ups.Ups'>, name='')

 

Parse a string representing a UTM or UPS coordinate, consisting of "zone[band] hemisphere/pole easting northing".

Arguments:
  • strUTMUPS - A UTM or UPS coordinate (str).
  • datum - Optional datum to use (Datum).
  • Utm - Optional class to return the UTM coordinate (Utm) or None.
  • Ups - Optional class to return the UPS coordinate (Ups) or None.
  • name - Optional instance name (str).
Returns:
The UTM or UPS instance (Utm or Ups) or a UtmUps5Tuple(zone, hemipole, easting, northing, band) if Utm respectively Ups or both are None. The hemipole is 'N'|'S', the UTM hemisphere or UPS pole, the UPS projection top/center.
Raises:

See Also: Functions pygeodesy.parseUTM5 and pygeodesy.parseUPS5.

parseWM (strWM, radius=6378137.0, Wm=<class 'pygeodesy.webmercator.Wm'>, name='')

 

Parse a string "e n [r]" representing a WM coordinate, consisting of easting, northing and an optional radius.

Arguments:
  • strWM - A WM coordinate (str).
  • radius - Optional earth radius (meter).
  • Wm - Optional class to return the WM coordinate (Wm) or None.
  • name - Optional name (str).
Returns:
The WM coordinate (Wm) or an EasNorRadius3Tuple(easting, northing, radius) if Wm is None.
Raises:

Example:

>>> u = parseWM('448251 5411932')
>>> u.toRepr()  # [E:448251, N:5411932]

perimeterOf (points, closed=False, adjust=True, radius=6371008.77141, wrap=True)

 

Approximate the perimeter of a path or polygon.

Arguments:
  • points - The path or polygon points (LatLon[]).
  • closed - Optionally, close the path or polygon (bool).
  • adjust - Adjust the wrapped, unrolled longitudinal delta by the cosine of the mean latitude (bool).
  • radius - Mean earth radius (meter).
  • wrap - Wrap lat-, wrap and unroll longitudes (bool).
Returns:
Approximate perimeter (meter, same units as radius).
Raises:
  • PointsError - Insufficient number of points
  • TypeError - Some points are not LatLon.
  • ValueError - Invalid radius.

Note: This perimeter is based on the pygeodesy.equirectangular_ distance approximation and is ill-suited for regions exceeding several hundred Km or Miles or with near-polar latitudes.

See Also: Functions sphericalTrigonometry.perimeterOf and ellipsoidalKarney.perimeterOf.

perimeterof (points, closed=False, adjust=True, radius=6371008.77141, wrap=True)

 

DEPRECATED, use function perimeterOf.

Decorators:
  • @deprecated_function

philam2n_xyz (phi, lam, name='')

 

Convert lat-, longitude to n-vector (normal to the earth's surface) X, Y and Z components.

Arguments:
  • phi - Latitude (radians).
  • lam - Longitude (radians).
  • name - Optional name (str).
Returns:
A Vector3Tuple(x, y, z).

See Also: Function latlon2n_xyz.

Note: These are n-vector x, y and z components, NOT geocentric ECEF x, y and z coordinates!

pierlot (point1, point2, point3, alpha12, alpha23, useZ=False, Clas=None, **Clas_kwds)

 

3-Point resection using Pierlot's method ToTal.

Arguments:
  • point1 - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • point2 - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • point3 - Third point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • alpha12 - Angle subtended from point1 to point2 (degrees).
  • alpha23 - Angle subtended from point2 to point3 (degrees).
  • useZ - If True, interpolate the Z component, otherwise use z=INT0 (bool).
  • Clas - Optional class to return the survey point or None for point1's (sub-)class.
  • Clas_kwds - Optional additional keyword arguments for the survey point instance.
Returns:
The survey (or robot) point, an instance of Clas or if Clas is None of point1's (sub-)class.
Raises:
  • ResectionError - Near-coincident, -colinear or -concyclic points or invalid alpha12 or alpha23.
  • TypeError - Invalid point1, point2 or point3.

points2 (points, closed=True, base=None, Error=<class 'pygeodesy.errors.PointsError'>)

 

Check a path or polygon represented by points.

Arguments:
  • points - The path or polygon points (LatLon[])
  • closed - Optionally, consider the polygon closed, ignoring any duplicate or closing final points (bool).
  • base - Optionally, check all points against this base class, if None don't check.
  • Error - Exception to raise (ValueError).
Returns:
A Points2Tuple(number, points) with the number of points and the points list or tuple.
Raises:
  • PointsError - Insufficient number of points.
  • TypeError - Some points are not base compatible.

polygon (points, closed=True, base=None)

 

DEPRECATED, use function points2.

Decorators:
  • @deprecated_function

precision (form, prec=None)

 

Set the default precison for a given F_ form.

Arguments:
Returns:
Previous precision for the form (int).
Raises:
  • ValueError - Invalid form or prec or prec outside the valid range -/+9.

print_ (*args, **nl_nt_prefix_end_file_flush_sep)

 

Python 3-style print function.

Arguments:
  • args - Values to be converted to str and concatenated (any types).
  • nl=0 - Number of leading blank lines (int).
  • nt=0 - Number of additional , trailing blank lines (int).
  • prefix=NN - To be inserted before the formatted text (str).

Note: Python 3+ keyword arguments end, file and flush are silently ignored.

printf (fmt, *args, **nl_nt_prefix_end_file_flush_sep)

 

C-style printf function.

Arguments:
  • fmt - C-style formating text (str).
  • args - Values to be formatted (any types).
  • nl=0 - Number of leading blank lines (int).
  • nt=0 - Number of additional , trailing blank lines (int).
  • prefix=NN - To be inserted before the formatted text (str).

Note: Python 3+ keyword arguments end, file, flush and sep are silently ignored.

property_doc_ (doc)

 

Decorator for a standard property with basic documentation.

Arguments:
  • doc - The property documentation (str).

Example:

>>> @property_doc_("documentation text.")
>>> def name(self):
>>>     ...
>>>
>>> @name.setter
>>> def name(self, value):
>>>     ...

quadOf (latS, lonW, latN, lonE, closed=False, LatLon=<class 'pygeodesy.points.LatLon_'>, **LatLon_kwds)

 

Generate a quadrilateral path or polygon from two points.

Arguments:
  • latS - Southernmost latitude (degrees90).
  • lonW - Westernmost longitude (degrees180).
  • latN - Northernmost latitude (degrees90).
  • lonE - Easternmost longitude (degrees180).
  • closed - Optionally, close the path (bool).
  • LatLon - Class to use (LatLon_).
  • LatLon_kwds - Optional, additional LatLon keyword arguments.
Returns:
Return a tuple of 4 or 5 LatLon instances outlining the quadrilateral.

See Also: Function boundsOf.

radians2m (rad, radius=6371008.77141, lat=0)

 

Convert an angle to a distance along the equator or along the parallel at an other (geodetic) latitude.

Arguments:
  • rad - The angle (radians).
  • radius - Mean earth radius, ellipsoid or datum (meter, Ellipsoid, Ellipsoid2, Datum or a_f2Tuple).
  • lat - Parallel latitude (degrees90, str).
Returns:
Distance (meter, same units as radius or equatorial and polar radii) or 0.0 for near-polar lat.
Raises:
  • RangeError - Latitude lat outside valid range and pygeodesy.rangerrors set to True.
  • TypeError - Invalid radius.
  • ValueError - Invalid rad, radius or lat.

See Also: Function degrees2m and m2radians.

radiansPI (deg)

 

Convert and wrap degrees to radians [-PI..+PI].

Arguments:
  • deg - Angle (degrees).
Returns:
Radians, wrapped (radiansPI)

radiansPI2 (deg)

 

Convert and wrap degrees to radians [0..+2PI).

Arguments:
  • deg - Angle (degrees).
Returns:
Radians, wrapped (radiansPI2)

radiansPI_2 (deg)

 

Convert and wrap degrees to radians [-3PI/2..+PI/2].

Arguments:
  • deg - Angle (degrees).
Returns:
Radians, wrapped (radiansPI_2)

radical2 (distance, radius1, radius2)

 

Compute the radical ratio and radical line of two intersecting circles.

The radical line is perpendicular to the axis thru the centers of the circles at (0, 0) and (distance, 0).

Arguments:
  • distance - Distance between the circle centers (scalar).
  • radius1 - Radius of the first circle (scalar).
  • radius2 - Radius of the second circle (scalar).
Returns:
A Radical2Tuple(ratio, xline) where 0.0 <= ratio <= 1.0 and xline is along the distance.
Raises:

radii11 (point1, point2, point3, useZ=True)

 

Return the radii of the In-, Soddy and Tangent circles of a (2- or 3-D) triangle.

Arguments:
  • point1 - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • point2 - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • point3 - Third point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • useZ - If True, use the Z components, otherwise force z=INT0 (bool).
Returns:
Radii11Tuple(rA, rB, rC, cR, rIn, riS, roS, a, b, c, s).
Raises:
  • TriangleError - Near-coincident or -colinear points.
  • TypeError - Invalid point1, point2 or point3.

randomrangenerator (seed)

 

Return a seeded random range function generator.

Arguments:
  • seed - Initial, internal Random state (hashable or None).
Returns:
A function to generate random ranges.

Note: Random with seed is None seeds from the current time or from a platform-specific randomness source, if available.

Example:

>>> rrange = randomrangenerator('R')
>>> for r in rrange(n):
>>>    ...  # r is random in 0..n-1

rangerrors (raiser=None)

 

Get/set the throwing of RangeErrors.

Arguments:
  • raiser - Choose True to raise or False to ignore RangeError exceptions. Use None to leave the setting unchanged.
Returns:
Previous setting (bool).

reprs (objs, prec=6, fmt='F', ints=False)

 

Convert objects to repr strings, with floats handled like fstr.

Arguments:
  • objs - List, sequence, tuple, etc. (any types).
  • prec - The float precision, number of decimal digits (0..9). Trailing zero decimals are stripped if prec is positive, but kept for negative prec values.
  • fmt - Optional, float format (str).
  • ints - Optionally, remove the decimal dot for int values (bool).
Returns:
A tuple(map(fstr|repr, objs)) of strs.

scalar (value, low=2.22044604925e-16, high=1.0, name='scalar', Error=<type 'exceptions.ValueError'>)

 

DEPRECATED, use class Number_ or Scalar_.

Returns:
New value (float or int for int low).
Decorators:
  • @deprecated_function
Raises:
  • Error - Invalid value.

signOf (x)

 

Return sign of x as int.

Returns:
-1, 0 or +1 (int).

simplify1 (points, distance=0.001, radius=6371008.77141, indices=False, **options)

 

Basic simplification of a path of LatLon points.

Eliminates any points closer together than the given distance tolerance.

Arguments:
  • points - Path points (LatLon[]).
  • distance - Tolerance (meter, same units as radius).
  • radius - Mean earth radius (meter).
  • indices - Optionally return the simplified point indices instead of the simplified points (bool).
  • options - Optional keyword arguments passed thru to function pygeodesy.equirectangular_.
Returns:
Simplified points (LatLon[]).
Raises:

simplify2 (points, pipe, radius=6371008.77141, shortest=False, indices=False, **options)

 

DEPRECATED, use function pygeodesy.simplifyRW.

Decorators:
  • @deprecated_function

simplifyRDP (points, distance=0.001, radius=6371008.77141, shortest=False, indices=False, **options)

 

Ramer-Douglas-Peucker (RDP) simplification of a path of LatLon points.

Eliminates any points too close together or closer to an edge than the given distance tolerance.

This RDP method exhaustively searches for the point with the largest distance, resulting in worst-case complexity O(n**2) where n is the number of points.

Arguments:
  • points - Path points (LatLon[]).
  • distance - Tolerance (meter, same units as radius).
  • radius - Mean earth radius (meter).
  • shortest - Optional, shortest or perpendicular distance (bool).
  • indices - Optionally return the simplified point indices instead of the simplified points (bool).
  • options - Optional keyword arguments passed thru to function pygeodesy.equirectangular_.
Returns:
Simplified points (LatLon[]).
Raises:

simplifyRDPm (points, distance=0.001, radius=6371008.77141, shortest=False, indices=False, **options)

 

Modified Ramer-Douglas-Peucker (RDPm) simplification of a path of LatLon points.

Eliminates any points too close together or closer to an edge than the given distance tolerance.

This RDPm method stops at the first point farther than the given distance tolerance, significantly reducing the run time (but producing results different from the original RDP method).

Arguments:
  • points - Path points (LatLon[]).
  • distance - Tolerance (meter, same units as radius).
  • radius - Mean earth radius (meter).
  • shortest - Optional, shortest or perpendicular distance (bool).
  • indices - Optionally return the simplified point indices instead of the simplified points (bool).
  • options - Optional keyword arguments passed thru to function pygeodesy.equirectangular_.
Returns:
Simplified points (LatLon[]).
Raises:

simplifyRW (points, pipe=0.001, radius=6371008.77141, shortest=False, indices=False, **options)

 

Reumann-Witkam (RW) simplification of a path of LatLon points.

Eliminates any points too close together or within the given pipe tolerance along an edge.

Arguments:
  • points - Path points (LatLon[]).
  • pipe - Pipe radius, half-width (meter, same units as radius).
  • radius - Mean earth radius (meter).
  • shortest - Optional, shortest or perpendicular distance (bool).
  • indices - Optionally return the simplified point indices instead of the simplified points (bool).
  • options - Optional keyword arguments passed thru to function pygeodesy.equirectangular_.
Returns:
Simplified points (LatLon[]).
Raises:

simplifyVW (points, area=0.001, radius=6371008.77141, attr=None, indices=False, **options)

 

Visvalingam-Whyatt (VW) simplification of a path of LatLon points.

Eliminates any points too close together or with a triangular area not exceeding the given area tolerance squared.

This VW method exhaustively searches for the single point with the smallest triangular area, resulting in worst-case complexity O(n**2) where n is the number of points.

Arguments:
  • points - Path points (LatLon[]).
  • area - Tolerance (meter, same units as radius).
  • radius - Mean earth radius (meter).
  • attr - Optional, points attribute to save the area value (str).
  • indices - Optionally return the simplified point indices instead of the simplified points (bool).
  • options - Optional keyword arguments passed thru to function pygeodesy.equirectangular_.
Returns:
Simplified points (LatLon[]).
Raises:
  • AttributeError - If an attr is specified for Numpy2 points.
  • LimitError - Lat- and/or longitudinal delta exceeds the limit, see function pygeodesy.equirectangular_.
  • ValueError - Tolerance area or radius too small.

simplifyVWm (points, area=0.001, radius=6371008.77141, attr=None, indices=False, **options)

 

Modified Visvalingam-Whyatt (VWm) simplification of a path of LatLon points.

Eliminates any points too close together or with a triangular area not exceeding the given area tolerance squared.

This VWm method removes all points with a triangular area below the tolerance in each iteration, significantly reducing the run time (but producing results different from the original VW method).

Arguments:
  • points - Path points (LatLon[]).
  • area - Tolerance (meter, same units as radius).
  • radius - Mean earth radius (meter).
  • attr - Optional, points attribute to save the area value (str).
  • indices - Optionally return the simplified point indices instead of the simplified points (bool).
  • options - Optional keyword arguments passed thru to function pygeodesy.equirectangular_.
Returns:
Simplified points (LatLon[]).
Raises:
  • AttributeError - If an attr is specified for Numpy2 points.
  • LimitError - Lat- and/or longitudinal delta exceeds the limit, see function pygeodesy.equirectangular_.
  • ValueError - Tolerance area or radius too small.

sincos2 (rad)

 

Return the sine and cosine of an angle in radians.

Arguments:
  • rad - Angle (radians).
Returns:
2-Tuple (sin(rad), cos(rad)).

See Also: GeographicLib function sincosd and C++ sincosd.

sincos2_ (*rads)

 

Return the sine and cosine of angle(s) in radians.

Arguments:
  • rads - One or more angles (radians).
Returns:
Yield the sin(rad) and cos(rad) for each angle.

See Also: function sincos2.

sincos2d (deg, **adeg)

 

Return the sine and cosine of an angle in degrees.

Arguments:
  • deg - Angle (degrees).
  • adeg - Optional correction (degrees).
Returns:
2-Tuple (sin(deg_), cos(deg_), deg_ = deg + adeg).

See Also: GeographicLib function sincosd and C++ sincosd.

sincos2d_ (*degs)

 

Return the sine and cosine of angle(s) in degrees.

Arguments:
  • degs - One or more angles (degrees).
Returns:
Yield the sin(deg) and cos(deg) for each angle.

See Also: Function sincos2d.

snellius3 (a, b, degC, alpha, beta)

 

Snellius' surveying using Snellius Pothenot.

Arguments:
  • a - Length of the triangle side between corners B and C and opposite of triangle corner A (scalar, non-negative meter, conventionally).
  • b - Length of the triangle side between corners C and A and opposite of triangle corner B (scalar, non-negative meter, conventionally).
  • degC - Angle at triangle corner C, opposite triangle side c (non-negative degrees).
  • alpha - Angle subtended by triangle side b (non-negative degrees).
  • beta - Angle subtended by triangle side a (non-negative degrees).
Returns:
Survey3Tuple(PA, PB, PC) with distance from survey point P to each of the triangle corners A, B and C, same units as triangle sides a, b and c.
Raises:
  • TriangleError - Invalid a, b or degC or negative alpha or beta.

See Also: Function pygeodesy.wildberger3.

soddy4 (point1, point2, point3, eps=8.881784197e-16, useZ=True)

 

Return the radius and center of the inner Soddy circle of a (2- or 3-D) triangle.

Arguments:
  • point1 - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • point2 - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • point3 - Third point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • eps - Tolerance for function pygeodesy.trilaterate3d2 if useZ is True otherwise pygeodesy.trilaterate2d2.
  • useZ - If True, use the Z components, otherwise force z=INT0 (bool).
Returns:
Soddy4Tuple(radius, center, deltas, outer). The center, an instance of point1's (sub-)class, is co-planar with the three given points.
Raises:
  • ImportError - Package numpy not found, not installed or older than version 1.10 and useZ is True.
  • IntersectionError - Near-coincident or -colinear points or a trilateration or numpy issue.
  • TypeError - Invalid point1, point2 or point3.

See Also: Functions radii11 and circum3.

splice (iterable, n=2, **fill)

 

Split an iterable into n slices.

Arguments:
  • iterable - Items to be spliced (list, tuple, ...).
  • n - Number of slices to generate (int).
  • fill - Optional fill value for missing items.
Returns:
A generator for each of n slices, iterable[i::n] for i=0..n.
Raises:
  • TypeError - Invalid n.

Note: Each generated slice is a tuple or a list, the latter only if the iterable is a list.

Example:

>>> from pygeodesy import splice
>>> a, b = splice(range(10))
>>> a, b
((0, 2, 4, 6, 8), (1, 3, 5, 7, 9))
>>> a, b, c = splice(range(10), n=3)
>>> a, b, c
((0, 3, 6, 9), (1, 4, 7), (2, 5, 8))
>>> a, b, c = splice(range(10), n=3, fill=-1)
>>> a, b, c
((0, 3, 6, 9), (1, 4, 7, -1), (2, 5, 8, -1))
>>> tuple(splice(list(range(9)), n=5))
([0, 5], [1, 6], [2, 7], [3, 8], [4])
>>> splice(range(9), n=1)
<generator object splice at 0x0...>

sqrt0 (x2)

 

Compute the square root iff x2 > EPS02.

Arguments:
  • x2 - Value (scalar).
Returns:
Square root (float) or 0.0.

Note: Any x2 < EPS02 including x2 < 0 returns 0.0.

sqrt3 (x2)

 

Compute the square root, cubed sqrt(x2)**3 or sqrt(x2**3).

Arguments:
  • x2 - Value (scalar).
Returns:
Cubed square root (float).
Raises:
  • ValueError - Negative x2.

See Also: Functions cbrt and cbrt2.

sqrt_a (h, b)

 

Compute a side of a right-angled triangle from sqrt(h**2 - b**2).

Arguments:
  • h - Hypotenuse or outer annulus radius (scalar).
  • b - Triangle side or inner annulus radius (scalar).
Returns:
copysign(a, h) or unsigned 0.0 (float).
Raises:
  • TypeError - Non-scalar h or b.
  • ValueError - If abs(h) < abs(b).

See Also: Inner tangent chord d of an annulus and function annulus_area.

strs (objs, prec=6, fmt='F', ints=False)

 

Convert objects to str strings, with floats handled like fstr.

Arguments:
  • objs - List, sequence, tuple, etc. (any types).
  • prec - The float precision, number of decimal digits (0..9). Trailing zero decimals are stripped if prec is positive, but kept for negative prec values.
  • fmt - Optional, float format (str).
  • ints - Optionally, remove the decimal dot for int values (bool).
Returns:
A tuple(map(fstr|str, objs)) of strs.

tanPI_2_2 (rad)

 

Compute the tangent of half angle, 90 degrees rotated.

Arguments:
  • rad - Angle (radians).
Returns:
tan((rad + PI/2) / 2) (float).

tan_2 (rad, **semi)

 

Compute the tangent of half angle.

Arguments:
  • rad - Angle (radians).
  • semi - Angle or edge name and index for semi-circular error.
Returns:
tan(rad / 2) (float).
Raises:
  • ValueError - If rad is semi-circular and semi is given.

tand (deg, **error_kwds)

 

Return the tangent of an angle in degrees.

Arguments:
  • deg - Angle (degrees).
  • error_kwds - Error to raise (ValueError).
Returns:
tan(deg).
Raises:

tand_ (*degs, **error_kwds)

 

Return the tangent of angle(s) in degrees.

Arguments:
  • degs - One or more angles (degrees).
  • error_kwds - Error to raise (ValueError).
Returns:
Yield the tan(deg) for each angle.
Raises:

thomas (lat1, lon1, lat2, lon2, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., wrap=False)

 

Compute the distance between two (ellipsoidal) points using Thomas' formula.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • datum - Datum or ellipsoid to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Distance (meter, same units as the datum's ellipsoid axes).
Raises:
  • TypeError - Invalid datum.

thomas_ (phi2, phi1, lam21, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...)

 

Compute the angular distance between two (ellipsoidal) points using Thomas' formula.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
  • datum - Datum or ellipsoid to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
Returns:
Angular distance (radians).
Raises:
  • TypeError - Invalid datum.

tienstra (pointA, pointB, pointC, alpha, **beta_gamma_useZ_Clas_and_kwds)

 

DEPRECATED, use function pygeodesy.tienstra7.

Decorators:
  • @deprecated_function

tienstra7 (pointA, pointB, pointC, alpha, beta=None, gamma=None, useZ=False, Clas=None, **Clas_kwds)

 

3-Point resection using Tienstra's formula.

Arguments:
  • pointA - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • pointB - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • pointC - Third point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
  • alpha - Angle subtended by triangle side a from pointB to pointC (degrees, non-negative).
  • beta - Angle subtended by triangle side b from pointA to pointC (degrees, non-negative) or None if gamma is not None.
  • gamma - Angle subtended by triangle side c from pointA to pointB (degrees, non-negative) or None if beta is not None.
  • useZ - If True, use and interpolate the Z component, otherwise force z=INT0 (bool).
  • Clas - Optional class to return the survey point or None for pointA's (sub-)class.
  • Clas_kwds - Optional additional keyword arguments for the survey point instance.
Returns:
Tienstra7Tuple(pointP, A, B, C, a, b, c) with survey pointP, an instance of Clas or if Clas is None of pointA's (sub-)class, with triangle angles A at pointA, B at pointB and C at pointC in degrees and with triangle sides a, b and c in meter, conventionally.
Raises:
  • ResectionError - Near-coincident, -colinear or -concyclic points or sum of alpha, beta and gamma not 360 or negative alpha, beta or gamma.
  • TypeError - Invalid pointA, pointB or pointC.

toCss (latlon, cs0=None, height=None, Css=<class 'pygeodesy.css.Css'>, name='')

 

Convert an (ellipsoidal) geodetic point to a Cassini-Soldner location.

Arguments:
  • latlon - Ellipsoidal point (LatLon or LatLon4Tuple).
  • cs0 - Optional, the Cassini-Soldner projection to use (CassiniSoldner).
  • height - Optional height for the point, overriding the default height (meter).
  • Css - Optional class to return the location (Css) or None.
  • name - Optional Css name (str).
Returns:
The Cassini-Soldner location (Css) or an EasNor3Tuple(easting, northing, height) if Css is None.
Raises:
  • CSSError - Ellipsoidal mismatch of latlon and cs0.
  • ImportError - Package geographiclib not installed or not found.
  • TypeError - If latlon is not ellipsoidal.

toDMS (deg, form='dms', prec=2, sep='', ddd=2, neg='-', pos='+', **s_D_M_S)

 

Convert signed degrees to string, without suffix.

Arguments:
Returns:
Degrees in the specified form (str).
Notes:
  • The degrees, minutes and seconds (DMS) symbol can be overridden in this and other *DMS functions by using optional keyword argments s_D="d", s_M="'" respectively s_S='"'.
  • Sexagecimal format F_D60 supports overridable pseudo-DMS symbols positioned at "[D]DD<s_D>MM<s_M>SS<s_S>" with defaults s_D=".", s_M=sep and s_S=pygeodesy.NN.
  • Formats F__E, F__F and F__G can be extended with a D-only symbol if defined with keyword argument s_D=str. Likewise for F_RAD formats with keyword argument s_R=str.

See Also: Function pygeodesy.degDMS

toEtm8 (latlon, lon=None, datum=None, Etm=<class 'pygeodesy.etm.Etm'>, falsed=True, name='', zone=None, **cmoff)

 

Convert a lat-/longitude point to an ETM coordinate.

Arguments:
  • latlon - Latitude (degrees) or an (ellipsoidal) geodetic LatLon point.
  • lon - Optional longitude (degrees) or None.
  • datum - Optional datum for this ETM coordinate, overriding latlon's datum (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
  • Etm - Optional class to return the ETM coordinate (Etm) or None.
  • falsed - False both easting and northing (bool).
  • name - Optional Utm name (str).
  • zone - Optional UTM zone to enforce (int or str).
  • cmoff - DEPRECATED, use falsed. Offset longitude from the zone's central meridian (bool).
Returns:
The ETM coordinate (Etm) or a UtmUps8Tuple(zone, hemipole, easting, northing, band, datum, convergence, scale) if Etm is None or not falsed. The hemipole is the 'N'|'S' hemisphere.
Raises:
  • EllipticError - No convergence transforming to ETM east- and northing.
  • ETMError - Invalid zone or near-spherical or incompatible datum or ellipsoid.
  • RangeError - If lat outside the valid UTM bands or if lat or lon outside the valid range and pygeodesy.rangerrors set to True.
  • TypeError - Invalid or near-spherical datum or latlon not ellipsoidal.
  • ValueError - The lon value is missing or latlon is invalid.

toLcc (latlon, conic=Conic(name='WRF_Lb', lat0=40, lon0=-97, par1=33, par2=45, E0=0..., height=None, Lcc=<class 'pygeodesy.lcc.Lcc'>, name='', **Lcc_kwds)

 

Convert an (ellipsoidal) geodetic point to a Lambert location.

Arguments:
  • latlon - Ellipsoidal point (LatLon).
  • conic - Optional Lambert projection to use (Conic).
  • height - Optional height for the point, overriding the default height (meter).
  • Lcc - Optional class to return the Lambert location (Lcc).
  • name - Optional Lcc name (str).
  • Lcc_kwds - Optional, additional Lcc keyword arguments, ignored if Lcc is None.
Returns:
The Lambert location (Lcc) or an EasNor3Tuple(easting, northing, height) if Lcc is None.
Raises:
  • TypeError - If latlon is not ellipsoidal.

toMgrs (utm, Mgrs=<class 'pygeodesy.mgrs.Mgrs'>, name='', **Mgrs_kwds)

 

Convert a UTM coordinate to an MGRS grid reference.

Arguments:
  • utm - A UTM coordinate (Utm or Etm).
  • Mgrs - Optional class to return the MGRS grid reference (Mgrs) or None.
  • name - Optional Mgrs name (str).
  • Mgrs_kwds - Optional, additional Mgrs keyword arguments, ignored if Mgrs is None.
Returns:
The MGRS grid reference as Mgrs or if Mgrs is None as an Mgrs6Tuple(zone, digraph, easting, northing, band, datum).
Raises:

Example:

>>> u = Utm(31, 'N', 448251, 5411932)
>>> m = u.toMgrs()  # 31U DQ 48251 11932

toOsgr (latlon, lon=None, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran..., Osgr=<class 'pygeodesy.osgr.Osgr'>, name='', **Osgr_kwds)

 

Convert a lat-/longitude point to an OSGR coordinate.

Arguments:
  • latlon - Latitude (degrees) or an (ellipsoidal) geodetic LatLon point.
  • lon - Optional longitude in degrees (scalar or None).
  • datum - Optional datum to convert lat, lon from (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
  • Osgr - Optional class to return the OSGR coordinate (Osgr) or None.
  • name - Optional Osgr name (str).
  • Osgr_kwds - Optional, additional Osgr keyword arguments, ignored if Osgr is None.
Returns:
The OSGR coordinate (Osgr) or an EasNor2Tuple(easting, northing) if Osgr is None.
Raises:
  • OSGRError - Invalid latlon or lon.
  • TypeError - Non-ellipsoidal latlon or invalid datum, Osgr, Osgr_kwds argument or conversion failed.

Example:

>>> p = LatLon(52.65798, 1.71605)
>>> r = toOsgr(p)  # TG 51409 13177
>>> # for conversion of (historical) OSGB36 lat-/longitude:
>>> r = toOsgr(52.65757, 1.71791, datum=Datums.OSGB36)

toUps8 (latlon, lon=None, datum=None, Ups=<class 'pygeodesy.ups.Ups'>, pole='', falsed=True, strict=True, name='')

 

Convert a lat-/longitude point to a UPS coordinate.

Arguments:
  • latlon - Latitude (degrees) or an (ellipsoidal) geodetic LatLon point.
  • lon - Optional longitude (degrees) or None if latlon is a LatLon.
  • datum - Optional datum for this UPS coordinate, overriding latlon's datum (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
  • Ups - Optional class to return the UPS coordinate (Ups) or None.
  • pole - Optional top/center of (stereographic) projection (str, 'N[orth]' or 'S[outh]').
  • falsed - False both easting and northing (bool).
  • strict - Restrict lat to UPS ranges (bool).
  • name - Optional Ups name (str).
Returns:
The UPS coordinate (Ups) or a UtmUps8Tuple(zone, hemipole, easting, northing, band, datum, convergence, scale) if Ups is None. The hemipole is the 'N'|'S' pole, the UPS projection top/center.
Raises:
  • RangeError - If strict and lat outside the valid UPS bands or if lat or lon outside the valid range and pygeodesy.rangerrors set to True.
  • TypeError - If latlon is not ellipsoidal or datum invalid.
  • ValueError - If lon value is missing or if latlon is invalid.

See Also: Karney's C++ class UPS.

toUtm (latlon, lon=None, datum=None, Utm=_UTM, cmoff=True, name='')

 

DEPRECATED, use function pygeodesy.toUtm8.

Returns:
The UTM coordinate (Utm) or a 6-tuple (zone, easting, northing, band, convergence, scale) if Utm is None or cmoff is False.
Decorators:
  • @deprecated_function

toUtm8 (latlon, lon=None, datum=None, Utm=<class 'pygeodesy.utm.Utm'>, falsed=True, name='', zone=None, **cmoff)

 

Convert a lat-/longitude point to a UTM coordinate.

Arguments:
  • latlon - Latitude (degrees) or an (ellipsoidal) geodetic LatLon point.
  • lon - Optional longitude (degrees) or None.
  • datum - Optional datum for this UTM coordinate, overriding latlon's datum (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).
  • Utm - Optional class to return the UTM coordinate (Utm) or None.
  • falsed - False both easting and northing (bool).
  • name - Optional Utm name (str).
  • zone - Optional UTM zone to enforce (int or str).
  • cmoff - DEPRECATED, use falsed. Offset longitude from the zone's central meridian (bool).
Returns:
The UTM coordinate (Utm) or if Utm is None or not falsed, a UtmUps8Tuple(zone, hemipole, easting, northing, band, datum, convergence, scale). The hemipole is the 'N'|'S' hemisphere.
Raises:
  • RangeError - If lat outside the valid UTM bands or if lat or lon outside the valid range and pygeodesy.rangerrors set to True.
  • TypeError - Invalid datum or latlon not ellipsoidal.
  • UTMError - Invalid zone.
  • ValueError - If lon value is missing or if latlon is invalid.

Note: Implements Karney’s method, using 8-th order Krüger series, giving results accurate to 5 nm (or better) for distances up to 3900 km from the central meridian.

Example:

>>> p = LatLon(48.8582, 2.2945)  # 31 N 448251.8 5411932.7
>>> u = toUtm(p)  # 31 N 448252 5411933
>>> p = LatLon(13.4125, 103.8667) # 48 N 377302.4 1483034.8
>>> u = toUtm(p)  # 48 N 377302 1483035

toUtmUps8 (latlon, lon=None, datum=None, falsed=True, Utm=<class 'pygeodesy.utm.Utm'>, Ups=<class 'pygeodesy.ups.Ups'>, pole='', name='', **cmoff)

 

Convert a lat-/longitude point to a UTM or UPS coordinate.

Arguments:
  • latlon - Latitude (degrees) or an (ellipsoidal) geodetic LatLon point.
  • lon - Optional longitude (degrees) or None.
  • datum - Optional datum to use this UTM coordinate, overriding latlon's datum (Datum).
  • falsed - False both easting and northing (bool).
  • Utm - Optional class to return the UTM coordinate (Utm) or None.
  • Ups - Optional class to return the UPS coordinate (Ups) or None.
  • pole - Optional top/center of UPS (stereographic) projection (str, 'N[orth]' or 'S[outh]').
  • name - Optional name (str).
  • cmoff - DEPRECATED, use falsed. Offset longitude from zone's central meridian, for UTM only (bool).
Returns:
The UTM or UPS coordinate (Utm respectively Ups) or a UtmUps8Tuple(zone, hemipole, easting, northing, band, datum, convergence, scale) if Utm respectively Ups is None or cmoff is False.
Raises:
  • RangeError - If lat outside the valid UTM or UPS bands or if lat or lon outside the valid range and pygeodesy.rangerrors set to True.
  • TypeError - If latlon is not ellipsoidal or lon value is missing of datum is invalid.
  • UTMUPSError - UTM or UPS validation failed.
  • ValueError - Invalid lat or lon.

See Also: Functions pygeodesy.toUtm8 and pygeodesy.toUps8.

toWm (latlon, lon=None, radius=6378137.0, Wm=<class 'pygeodesy.webmercator.Wm'>, name='', **Wm_kwds)

 

Convert a lat-/longitude point to a WM coordinate.

Arguments:
  • latlon - Latitude (degrees) or an (ellipsoidal or spherical) geodetic LatLon point.
  • lon - Optional longitude (degrees or None).
  • radius - Optional earth radius (meter).
  • Wm - Optional class to return the WM coordinate (Wm) or None.
  • name - Optional name (str).
  • Wm_kwds - Optional, additional Wm keyword arguments, ignored if Wm is None.
Returns:
The WM coordinate (Wm) or if Wm is None an EasNorRadius3Tuple(easting, northing, radius).
Raises:
  • ValueError - If lon value is missing, if latlon is not scalar, if latlon is beyond the valid WM range and pygeodesy.rangerrors is set to True or if radius is invalid.

Example:

>>> p = LatLon(48.8582, 2.2945)  # 448251.8 5411932.7
>>> w = toWm(p)  # 448252 5411933
>>> p = LatLon(13.4125, 103.8667)  # 377302.4 1483034.8
>>> w = toWm(p)  # 377302 1483035

toise2m (toises)

 

Convert French toises to meter.

Arguments:
  • toises - Value in toises (scalar).
Returns:
Value in meter (float).
Raises:
  • ValueError - Invalid toises.

See Also: Function fathom2m.

trfXform (reframe1, reframe2, epoch=None, xform=None, rates=None)

 

Define a new Terrestrial Reference Frame (TRF) conversion.

Arguments:
  • reframe1 - Source reframe (RefFrame), converting from.
  • reframe2 - Destination reframe (RefFrame), converting to.
  • epoch - Epoch, a fractional calendar year (scalar or str) or None for reframe2.epoch.
  • xform - Helmert transform (Tranform7Tuple).
  • rates - Helmert transform (Tranform7Tuple).
Raises:
  • TRFError - Invalid epoch or TRF conversion already exists.

triAngle (a, b, c)

 

Compute one angle of a triangle.

Arguments:
  • a - Adjacent triangle side length (scalar, non-negative meter, conventionally).
  • b - Adjacent triangle side length (scalar, non-negative meter, conventionally).
  • c - Opposite triangle side length (scalar, non-negative meter, conventionally).
Returns:
Angle in radians at triangle corner C, opposite triangle side c.
Raises:

See Also: Functions pygeodesy.triAngle4 and pygeodesy.triSide.

triAngle4 (a, b, c)

 

Compute the angles of a triangle.

Arguments:
  • a - Length of the triangle side opposite of triangle corner A (scalar, non-negative meter, conventionally).
  • b - Length of the triangle side opposite of triangle corner B (scalar, non-negative meter, conventionally).
  • c - Length of the triangle side opposite of triangle corner C (scalar, non-negative meter, conventionally).
Returns:
TriAngle4Tuple(radA, radB, radC, rIn) with angles radA, radB and radC at triangle corners A, B and C, all in radians and the InCircle radius rIn aka inradius, same units as triangle sides a, b and c.
Raises:

See Also: Function pygeodesy.triAngle.

triSide (a, b, radC)

 

Compute one side of a triangle.

Arguments:
  • a - Adjacent triangle side length (scalar, non-negative meter, conventionally).
  • b - Adjacent triangle side length (scalar, non-negative meter, conventionally).
  • radC - Angle included by sides a and b, opposite triangle side c (radians).
Returns:
Length of triangle side c, opposite triangle corner C and angle radC, same units as a and b.
Raises:

triSide2 (b, c, radB)

 

Compute one side and the opposite angle of a triangle.

Arguments:
  • b - Adjacent triangle side length (scalar, non-negative meter, conventionally).
  • c - Adjacent triangle side length (scalar, non-negative meter, conventionally).
  • radB - Angle included by sides a and c, opposite triangle side b (radians).
Returns:
TriSide2Tuple(a, radA) with triangle angle radA in radians and length of the opposite triangle side a, same units as b and c.
Raises:

triSide4 (radA, radB, c)

 

Compute two sides and the height of a triangle.

Arguments:
  • radA - Angle at triangle corner A, opposite triangle side a (non-negative radians).
  • radB - Angle at triangle corner B, opposite triangle side b (non-negative radians).
  • c - Length of triangle side between triangle corners A and B, (scalar, non-negative meter, conventionally).
Returns:
TriSide4Tuple(a, b, radC, d) with triangle sides a and b and triangle height d perpendicular to triangle side c, all in the same units as c and interior angle radC in radians at triangle corner C, opposite triangle side c.
Raises:

trilaterate2d2 (x1, y1, radius1, x2, y2, radius2, x3, y3, radius3, eps=None, **Vector_and_kwds)

 

Trilaterate three circles, each given as a (2-D) center and a radius.

Arguments:
  • x1 - Center x coordinate of the 1st circle (scalar).
  • y1 - Center y coordinate of the 1st circle (scalar).
  • radius1 - Radius of the 1st circle (scalar).
  • x2 - Center x coordinate of the 2nd circle (scalar).
  • y2 - Center y coordinate of the 2nd circle (scalar).
  • radius2 - Radius of the 2nd circle (scalar).
  • x3 - Center x coordinate of the 3rd circle (scalar).
  • y3 - Center y coordinate of the 3rd circle (scalar).
  • radius3 - Radius of the 3rd circle (scalar).
  • eps - Check the trilaterated point delta on all 3 circles (scalar) or None.
  • Vector_and_kwds - Optional class Vector=None to return the trilateration and optional, additional Vector keyword arguments, otherwise (Vector3d).
Returns:
Trilaterated point as Vector(x, y, **Vector_kwds) or Vector2Tuple(x, y) if Vector is None..
Raises:
  • IntersectionError - No intersection, near-concentric or -colinear centers, trilateration failed some other way or the trilaterated point is off one circle by more than eps.
  • UnitError - Invalid radius1, radius2 or radius3.

trilaterate3d2 (center1, radius1, center2, radius2, center3, radius3, eps=2.22044604925e-16, **Vector_and_kwds)

 

Trilaterate three spheres, each given as a (3-D) center and a radius.

Arguments:
  • center1 - Center of the 1st sphere (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • radius1 - Radius of the 1st sphere (same units as x, y and z).
  • center2 - Center of the 2nd sphere (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • radius2 - Radius of this sphere (same units as x, y and z).
  • center3 - Center of the 3rd sphere (Cartesian, Vector3d, Vector3Tuple or Vector4Tuple).
  • radius3 - Radius of the 3rd sphere (same units as x, y and z).
  • eps - Tolerance (scalar), same units as x, y, and z.
  • Vector_and_kwds - Optional class Vector=None to return the trilateration and optional, additional Vector keyword arguments, otherwise center1's (sub-)class.
Returns:
2-Tuple with two trilaterated points, each a Vector instance. Both points are the same instance if all three spheres abut/intersect in a single point.
Raises:
  • ImportError - Package numpy not found, not installed or older than version 1.10.
  • IntersectionError - Near-concentric, -colinear, too distant or non-intersecting spheres.
  • NumPyError - Some numpy issue.
  • TypeError - Invalid center1, center2 or center3.
  • UnitError - Invalid radius1, radius2 or radius3.

tyr3d (tilt=0, yaw=0, roll=0, Vector=<class 'pygeodesy.vector3d.Vector3d'>, **Vector_kwds)

 

Convert an attitude oriention into a (3-D) direction vector.

Arguments:
  • tilt - Pitch, elevation from horizontal (degrees), negative down (clockwise rotation along and around the x-axis).
  • yaw - Bearing, heading (compass degrees360), clockwise from North (counter-clockwise rotation along and around the z-axis).
  • roll - Roll, bank (degrees), positive to the right and down (clockwise rotation along and around the y-axis).
Returns:
A named Vector instance or if Vector is None, a named Vector3Tuple(x, y, z).

See Also: Yaw, pitch, and roll rotations and function pygeodesy.hartzell argument los.

unStr (name, *args, **kwds)

 

DEPRECATED, use function pygeodesy.unstr.

Decorators:
  • @deprecated_function

unroll180 (lon1, lon2, wrap=True)

 

Unroll longitudinal delta and wrap longitude in degrees.

Arguments:
  • lon1 - Start longitude (degrees).
  • lon2 - End longitude (degrees).
  • wrap - Wrap and unroll to the (-180..+180] range (bool).
Returns:
2-Tuple (lon2-lon1, lon2) unrolled (degrees, degrees).

See Also: Capability LONG_UNROLL in GeographicLib.

unrollPI (rad1, rad2, wrap=True)

 

Unroll longitudinal delta and wrap longitude in radians.

Arguments:
  • rad1 - Start longitude (radians).
  • rad2 - End longitude (radians).
  • wrap - Wrap and unroll to the (-PI..+PI] range (bool).
Returns:
2-Tuple (rad2-rad1, rad2) unrolled (radians, radians).

See Also: Capability LONG_UNROLL in GeographicLib.

unsign0 (x)

 

DEPRECATED, use function pygeodesy.unsigned0.

Decorators:
  • @deprecated_function

unsigned0 (x)

 

Return 0.0 unsigned.

Returns:
x if x else 0.0.

unstr (named, *args, **kwds)

 

Return the string representation of an invokation.

Arguments:
  • named - Function, method or class name (str).
  • args - Optional positional arguments.
  • kwds - Optional keyword arguments.
Returns:
Representation (str).

upsZoneBand5 (lat, lon, strict=True, name='')

 

Return the UTM/UPS zone number, polar Band letter, pole and clipped lat- and longitude for a given location.

Arguments:
  • lat - Latitude in degrees (scalar or str).
  • lon - Longitude in degrees (scalar or str).
  • strict - Restrict lat to UPS ranges (bool).
  • name - Optional name (str).
Returns:
A UtmUpsLatLon5Tuple(zone, band, hemipole, lat, lon) where hemipole is the 'N'|'S' pole, the UPS projection top/center.
Raises:
  • RangeError - If strict and lat in the UTM and not the UPS range or if lat or lon outside the valid range and pygeodesy.rangerrors set to True.
  • ValueError - Invalid lat or lon.

utmZoneBand2 (lat, lon)

 

DEPRECATED, use function pygeodesy.utmZoneBand5.

Returns:
2-Tuple (zone, band).
Decorators:
  • @deprecated_function

utmZoneBand5 (lat, lon, cmoff=False, name='')

 

Return the UTM zone number, Band letter, hemisphere and (clipped) lat- and longitude for a given location.

Arguments:
  • lat - Latitude in degrees (scalar or str).
  • lon - Longitude in degrees (scalar or str).
  • cmoff - Offset longitude from the zone's central meridian (bool).
  • name - Optional name (str).
Returns:
A UtmUpsLatLon5Tuple(zone, band, hemipole, lat, lon) where hemipole is the 'N'|'S' UTM hemisphere.
Raises:
  • RangeError - If lat outside the valid UTM bands or if lat or lon outside the valid range and pygeodesy.rangerrors set to True.
  • ValueError - Invalid lat or lon.

utmupsValidate (coord, falsed=False, MGRS=False, Error=<class 'pygeodesy.utmups.UTMUPSError'>)

 

Check a UTM or UPS coordinate.

Arguments:
  • coord - The UTM or UPS coordinate (Utm, Ups or 5+Tuple).
  • falsed - 5+Tuple easting and northing are falsed (bool).
  • MGRS - Increase easting and northing ranges (bool).
  • Error - Optional error to raise, overriding the default (UTMUPSError).
Returns:
None if validation passed.
Raises:
  • Error - Validation failed.

See Also: Function utmupsValidateOK.

utmupsValidateOK (coord, falsed=False, ok=True)

 

Check a UTM or UPS coordinate.

Arguments:
  • coord - The UTM or UPS coordinate (Utm, Ups or 5+Tuple).
  • falsed - 5+Tuple easting and northing are falsed (bool).
  • ok - Result to return if validation passed (ok).
Returns:
ok if validation passed, the UTMUPSError otherwise.

See Also: Function utmupsValidate.

utmupsZoneBand5 (lat, lon, cmoff=False, name='')

 

Return the UTM/UPS zone number, Band letter, hemisphere/pole and clipped lat- and longitude for a given location.

Arguments:
  • lat - Latitude in degrees (scalar or str).
  • lon - Longitude in degrees (scalar or str).
  • cmoff - Offset longitude from the zone's central meridian, for UTM only (bool).
  • name - Optional name (str).
Returns:
A UtmUpsLatLon5Tuple(zone, band, hemipole, lat, lon) where hemipole is 'N'|'S', the UTM hemisphere or UPS pole, the UPS projection top/center.
Raises:
  • RangeError - If lat outside the valid UTM or UPS bands or if lat or lon outside the valid range and pygeodesy.rangerrors set to True.
  • ValueError - Invalid lat or lon.

vincentys (lat1, lon1, lat2, lon2, radius=6371008.77141, wrap=False)

 

Compute the distance between two (spherical) points using Vincenty's spherical formula.

Arguments:
  • lat1 - Start latitude (degrees).
  • lon1 - Start longitude (degrees).
  • lat2 - End latitude (degrees).
  • lon2 - End longitude (degrees).
  • radius - Mean earth radius, ellipsoid or datum (meter, Ellipsoid, Ellipsoid2, Datum or a_f2Tuple).
  • wrap - Wrap and pygeodesy.unroll180 longitudes (bool).
Returns:
Distance (meter, same units as radius).
Raises:

See Also: Functions vincentys_, cosineAndoyerLambert, cosineForsytheAndoyerLambert,cosineLaw, equirectangular, euclidean, flatLocal/hubeny, flatPolar, haversine and thomas and methods Ellipsoid.distance2, LatLon.distanceTo* and LatLon.equirectangularTo.

Note: See note at function vincentys_.

vincentys_ (phi2, phi1, lam21)

 

Compute the angular distance between two (spherical) points using Vincenty's spherical formula.

Arguments:
  • phi2 - End latitude (radians).
  • phi1 - Start latitude (radians).
  • lam21 - Longitudinal delta, end-start (radians).
Returns:
Angular distance (radians).

See Also: Functions vincentys, cosineAndoyerLambert_, cosineForsytheAndoyerLambert_, cosineLaw_, equirectangular_, euclidean_, flatLocal_/hubeny_, flatPolar_, haversine_ and thomas_.

Note: Functions vincentys_, haversine_ and cosineLaw_ produce equivalent results, but vincentys_ is suitable for antipodal points and slightly more expensive (3 cos, 3 sin, 1 hypot, 1 atan2, 6 mul, 2 add) than haversine_ (2 cos, 2 sin, 2 sqrt, 1 atan2, 5 mul, 1 add) and cosineLaw_ (3 cos, 3 sin, 1 acos, 3 mul, 1 add).

wildberger3 (a, b, c, alpha, beta, R3=<built-in function min>)

 

Snellius' surveying using Rational Trigonometry.

Arguments:
  • a - Length of the triangle side between corners B and C and opposite of triangle corner A (scalar, non-negative meter, conventionally).
  • b - Length of the triangle side between corners C and A and opposite of triangle corner B (scalar, non-negative meter, conventionally).
  • c - Length of the triangle side between corners A and B and opposite of triangle corner C (scalar, non-negative meter, conventionally).
  • alpha - Angle subtended by triangle side b (degrees, non-negative).
  • beta - Angle subtended by triangle side a (degrees, non-negative).
  • R3 - Callable to determine R3 from (R3 - C)**2 = D, typically standard function min or max, invoked with 2 arguments.
Returns:
Survey3Tuple(PA, PB, PC) with distance from survey point P to each of the triangle corners A, B and C, same units as a, b and c.
Raises:
  • TriangleError - Invalid a, b or c or negative alpha or beta or R3 not callable.

wrap180 (deg)

 

Wrap degrees to [-180..+180].

Arguments:
  • deg - Angle (degrees).
Returns:
Degrees, wrapped (degrees180).

wrap360 (deg)

 

Wrap degrees to [0..+360).

Arguments:
  • deg - Angle (degrees).
Returns:
Degrees, wrapped (degrees360).

wrap90 (deg)

 

Wrap degrees to [-270..+90].

Arguments:
  • deg - Angle (degrees).
Returns:
Degrees, wrapped (degrees90).

wrapPI (rad)

 

Wrap radians to [-PI..+PI].

Arguments:
  • rad - Angle (radians).
Returns:
Radians, wrapped (radiansPI).

wrapPI2 (rad)

 

Wrap radians to [0..+2PI).

Arguments:
  • rad - Angle (radians).
Returns:
Radians, wrapped (radiansPI2).

wrapPI_2 (rad)

 

Wrap radians to [-3PI/2..+PI/2].

Arguments:
  • rad - Angle (radians).
Returns:
Radians, wrapped (radiansPI_2).

yard2m (yards)

 

Convert UK yards to meter.

Arguments:
  • yards - Value in yards (scalar).
Returns:
Value in meter (float).
Raises:
  • ValueError - Invalid yards.

Variables Details

pygeodesy_abspath

Fully qualified pygeodesy directory name (str).
Value:
'..../PyGeodesy/pygeodesy'

Conics

Registered, predefined conics (enum-like).
Value:
Conics.WRF_Lb: Conic(name='WRF_Lb', lat0=40, lon0=-97, par1=33, par2=4\
5, E0=0, N0=0, k0=1, SP=2, datum=Datum(name='WGS84', ellipsoid=Ellipso\
ids.WGS84, transform=Transforms.WGS84)

Datums

Registered, predefined datums (enum-like).
Value:
Datums.OSGB36: Datum(name='OSGB36', ellipsoid=Ellipsoids.Airy1830, tra\
nsform=Transforms.OSGB36),
Datums.Sphere: Datum(name='Sphere', ellipsoid=Ellipsoids.Sphere, trans\
form=Transforms.WGS84),
Datums.WGS84: Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transfor\
m=Transforms.WGS84)

Ellipsoids

Registered, predefined ellipsoids (enum-like).
Value:
Ellipsoids.Airy1830: Ellipsoid(name='Airy1830', a=6377563.396, b=63562\
56.90923729, f_=299.3249646, f=0.00334085, f2=0.00335205, n=0.00167322\
, e=0.08167337, e2=0.00667054, e22=0.00671533, e32=0.00334643, A=63669\
14.60892522, L=10001126.0807165, R1=6370461.23374576, R2=6370459.65470\
808, R3=6370453.30994572, Rbiaxial=6366919.065224, Rtriaxial=6372243.4\
5317691),
Ellipsoids.Sphere: Ellipsoid(name='Sphere', a=6371008.771415, b=637100\
8.771415, f_=0, f=0, f2=0, n=0, e=0, e2=0, e22=0, e32=0, A=6371008.771\
...

Transforms

Registered, predefined transforms (enum-like).
Value:
Transforms.OSGB36: Transform(name='OSGB36', tx=-446.448, ty=125.157, t\
z=-542.06, rx=-0, ry=-0, rz=-0, s=20.4894, s1=1.00002, sx=-0.1502, sy=\
-0.247, sz=-0.8421),
Transforms.WGS84: Transform(name='WGS84', tx=0, ty=0, tz=0, rx=0, ry=0\
, rz=0, s=0, s1=1, sx=0, sy=0, sz=0)