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, elliptic and approximate methods for geodetic (lat-/longitude) and geocentric (ECEF cartesian) coordinates.

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

There are three modules for ellipsoidal earth models, `ellipsoidalKarney`, `-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, area, perimeter, initial and final bearing, intermediate and nearest points, intersections of circles, path intersections, 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 the Python 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, azimuthal projections and Lambert conformal conic projections and positions (from John P. Snyder, "Map Projections -- A Working Manual", 1987), functions to clip a path or polygon of `LatLon` points using the Cohen–Sutherland and the Sutherland-Hodgman methods, functions to simplify or linearize a path of `tLon` points (or a NumPy array), including implementations of the Ramer-Douglas-Peucker the Visvalingam-Whyatt and Reumann-Witkam the algorithms and modified versions of the former. Other classes interpolate the height of `LatLon` points and several `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 setup.py install`. To run all PyGeodesy tests, type `python setup.py test` before or after installation.

Installation of geographiclib, numpy and scipy is optional. However, the former is required to use classes EquidistantKarney, GnomonicKarney, CassiniSoldner and Css and function toCss, for module ellipsoidalKarney classes `LatLon` and `Cartesian` and functions `areaOf`, `intersections2` and `perimeterOf` and for the HeightIDWkarney interpolator. Both the latter are needed for the `Geoid...` and `Height...` interpolator classes, except the GeoidKarney and all `HeightIDW...` classes.

# 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.8.5, 3.7.6 and 2.7.18 (all with geographiclib 1.50, numpy 1.19.0, 1.17.2 respectively 1.16.5 and scipy 1.5.0, 1.3.1 respectively 1.2.2) and with Python 3.9.0rc1 and macOS' Python 2.7.16 (both without geographiclib, numpy and scipy), all on macOS 10.15.6 Catalina and all in 64-bit only. The tests run with and without `lazy import` for Python 3. The results of those tests are included in the distribution files.

Test coverage has been measured with coverage 4.5.4 using Python 3.8.5 and 3.7.6 (both with geographiclib 1.50, numpy 1.19.0 respectively 1.17.2 and scipy 1.5.0 respectively 1.3.1) and macOS' Python 2.7.16 (without geographiclib, numpy and scipy). The full HMTL report and a PDF summary are included in the distribution files.

The tests also ran with Python 2.7.14, 3.5.6, 3.6.3, 3.7.1, 3.8.0 and PyPy 7.1.1 (Python 2.7.13 and 3.6.1) (and geographiclib 1.49 or 1.50) on Ubuntu 14.04 and with Python 3.7.3 (and geographiclib 1.49 or 1.50) on Debian 9 all in 64-bit only and with Python 2.7.15, 3.6.8, 3.7.2, and 3.8.0 (all with geographiclib 1.49 or 1.50) on Windows Server 2012R2 in both 32- and 64-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 2.6.9 (and numpy 1.6.2), 2.7.10 (and numpy 1.8.0rc1), 2.7.13 thru 2.7.17 (and numpy 1.13.1, 1.14.0, 1.15.2 or 1.16.2), 3.5.3, 3.6.2 thru 3.6.5, 3.7.0, 3.7.2 thru 3.7.5, 3.8 thru 3.8.3, PyPy 6.0.0 (Python 2.7.13 and 3.5.3), PyPy 7.3.0 (Python 2.7.13 and 3.6.9) and Intel-Python 3.5.3 (and numpy 1.11.3) on MacOS X 10.10 Yosemite, MacOS X 10.11 El Capitan, macOS 10.12 Sierra, macOS 10.13.6 High Sierra, macOS 10.14 Mojave and/or macOS 10.15.3 and 10.15.5 Catalina, with Pythonista 3.1 on iOS 10.3.3, 11.0.3, 11.1.2 and 11.3 on iPad4, with Pythonista 3.2 (with geographiclib 1.49 or 1.50 and numpy 1.8.0) on iOS 11.4.1, 12.0, 12.2 and 12.3 on iPad4, iPhone6 and/or iPhone10, all in 64-bit only and with 32-bit Python 2.6.6 on Windows XP SP3 and with 32-bit Python 2.7.14 on Windows 10 Pro.

# 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.8.3, both in 64-bit on macOS 10.15.6 Catalina.

Classes with a name ending in `-Karney` and several more are transcribed from Karney's C++ classes or require Karney's geographiclib package to be installed. A complete list is in module karney.

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

# License

**) Copyright (C) 2016-2020 -- 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: 20.09.02

Submodules
pygeodesy.__main__: Print pygeodesy version, etc. pygeodesy.albers: Classes AlbersEqualArea, AlbersEqualArea2, AlbersEqualArea4, AlbersEqualAreaCylindrical, AlbersEqualAreaNorth, AlbersEqualAreaSouth and AlbersError, a transcription of Charles Karney's C++ class AlbersEqualArea. pygeodesy.azimuthal: Azimuthal projection classes Equidistant, EquidistantKarney, Gnomonic, GnomonicKarney, LambertEqualArea, Orthographic, Stereographic and AzimuthalError and functions equidistant and gnomonic. pygeodesy.bases: DEPRECATED, use module latlonBase instead. pygeodesy.basics: Basic constants, definitions and functions. pygeodesy.cartesianBase: (INTERNAL) Base classes for elliposiodal, spherical and N-/vectorial `Cartesian`s. pygeodesy.clipy: Functions to clip a path or polygon of `LatLon` points against a rectangular box or clip region. pygeodesy.css: Cassini-Soldner projection classes CassiniSoldner, Css and CSSError requiring Charles Karney's geographiclib package to be installed. pygeodesy.datum: DEPRECATED, use module datums or ellipsoids instead. pygeodesy.datums: Classes Datum and Transform and registries thereof Datums and Transforms, respectively. pygeodesy.deprecated: DEPRECATED classes, functions, etc. pygeodesy.dms: Functions to parse and format bearing, compass, lat- and longitudes in various forms of degrees, minutes and seconds. pygeodesy.ecef: Geocentric conversions transcribed from Charles Karney's C++ classes Geocentric and LocalCartesian into pure Python classes EcefKarney respectively EcefCartesian, class EcefSudano based on John Sudano's paper, class EcefVeness transcribed from Chris Veness' JavaScript classes LatLonEllipsoidal, Cartesian and class EcefYou implementing Rey-Jer You's transformations. pygeodesy.elevations: Functions to obtain elevations and geoid heights thru web services, for (lat, lon) locations, currently limited to the Conterminous US (CONUS), see also module geoids, module heights classes and USGS10mElev.py. pygeodesy.ellipsoidalBase: (INTERNAL) Ellipsoidal base classes `CartesianEllipsoidalBase` and `LatLonEllipsoidalBase`. pygeodesy.ellipsoidalKarney: Ellipsoidal classes geodetic (lat-/longitude) LatLon and geocentric (ECEF) Cartesian and functions areaOf, isclockwise and perimeterOf, all based on Charles Karney's Python geographiclib. pygeodesy.ellipsoidalNvector: Ellispdoidal, N-vector-based classes geodetic (lat-/longitude) LatLon, geocentric (ECEF) Cartesian, Ned and Nvector and functions meanOf and toNed. pygeodesy.ellipsoidalVincenty: Ellispodial classes for Vincenty's geodetic (lat-/longitude) LatLon, geocentric (ECEF) Cartesian and VincentyError and functions areaOf and perimeterOf. pygeodesy.ellipsoids: Classes a_f2Tuple, Ellipsoid, Ellipsoid2, an Ellipsoids registry and a dozen functions to convert equatorial radius, polar radius, eccentricities, flattenings and inverse flattening. pygeodesy.elliptic: Elliptic integrals and functions transcribed from Charles Karney's C++ class EllipticFunction into pure Python class Elliptic. pygeodesy.epsg: Classes Epsg and EPSGError and functions to encode and decode2 European Petroleum Survey Group (EPSG) codes from and to UTM and UPS zones. pygeodesy.errors: Error, exception classes and functions to format PyGeodesy errors, including the setting of exception chaining in Python 3+. pygeodesy.etm: Classes ETMError and Etm, a pure Python transcription of Charles Karney's C++ class TransverseMercatorExact, abbreviated as `TMExact` below. pygeodesy.fmath: Precision floating point functions, utilities and constants. pygeodesy.formy: Formulary of basic geodesy functions and approximations. pygeodesy.frechet: Classes Frechet, FrechetDegrees, FrechetRadians, FrechetCosineAndoyerLambert, FrechetCosineForsytheAndoyerLambert, FrechetCosineLaw, FrechetDistanceTo< FrechetEquirectangular, FrechetEuclidean, FrechetFlatLocal, FrechetFlatPolar, FrechetHaversine, FrechetHubeny, FrechetKarney, FrechetThomas and FrechetVincentys to compute discrete Fréchet distances between two sets of `LatLon`, `NumPy`, `tuples` or other types of points. pygeodesy.gars: Classes Garef and GARSError and several functions to encode, decode and inspect Global Area Reference System (GARS) references. pygeodesy.geohash: Classes Geohash and GeohashError and several functions to encode, decode and inspect geohashes. pygeodesy.geoids: Classes GeoidG2012B, GeoidKarney and GeoidPGM to interpolate the height of various geoids at `LatLon` locations or separate lat-/longitudes using different interpolation methods and `geoid` files. pygeodesy.hausdorff: Classes Hausdorff, HausdorffDegrees, HausdorffRadians, HausdorffCosineAndoyerLambert, HausdorffCosineForsytheAndoyerLambert, HausdorffCosineLaw, HausdorffDistanceTo, HausdorffEquirectangular, HausdorffEuclidean, HausdorffFlatLocal, HausdorffFlatPolar, HausdorffHaversine, HausdorffHubeny, HausdorffKarney, HausdorffThomas and HausdorffVincentys to compute Hausdorff distances between two sets of `LatLon`, `NumPy`, `tuples` or other types of points. pygeodesy.heights: Classes HeightCubic, HeightIDWcosineAndoyerLambert, HeightIDWcosineForsytheAndoyerLambert, HeightIDWcosineLaw, HeightIDWdistanceTo, HeightIDWequirectangular, HeightIDWeuclidean, HeightIDWflatLocal, HeightIDWflatPolar, HeightIDWhaversine, HeightIDWhubeny, HeightIDWkarney, HeightIDWthomas, HeightIDWvincentys, HeightLinear, HeightLSQBiSpline and HeightSmoothBiSpline to interpolate the height of `LatLon` locations or separate lat-/longitudes from a set of `LatLon` points with known heights. pygeodesy.interns: Single-instance floats and strings, `intern`'ed across modules. pygeodesy.karney: Wrapper around Charles Karney's Python classes `Geodesic` and `GeodesicLine` and functions `AngDiff`, `AngNormalize`, `LatFix` and `sum` from geographiclib, provided that package is installed. pygeodesy.latlonBase: (INTERNAL) base classes for elliposiodal, spherical and vectorial `LatLon`s. pygeodesy.lazily: Lazily import `pygeodesy` modules and attributes, based on lazy_import from Brett Cannon's modutil. pygeodesy.lcc: Lambert conformal conic projection for 1- or 2-Standard Parallels classes Conic, Conics registry, LCCError and position class Lcc. pygeodesy.mgrs: Military Grid Reference System (MGRS/NATO) classes Mgrs and MGRSError and functions parseMGRS and toMgrs. pygeodesy.named: (INTERNAL) Classes `_Named`, `_NamedDict` and `_NamedTuple`, all with nameable instances and several subclasses thereof. pygeodesy.nvector: DEPRECATED, use module nvectorBase instead. pygeodesy.nvectorBase: (INTERNAL) Base classes LatLonNvectorBase and NvectorBase and function sumOf for `N-vectorial` ellipsoidal and spherical `Cartesian`s and `LatLon`s. pygeodesy.osgr: Ordinance Survey Grid References (OSGR) classes Osgr an OSGRError and functions parseOSGR and toOsgr. pygeodesy.points: Functions to handle collections and sequences of `LatLon` points specified as 2-d NumPy, `arrays` or tuples as `LatLon` or as `pseudo-x/-y` pairs. pygeodesy.simplify: Seven functions to simplify or linearize a path of `LatLon` points. pygeodesy.sphericalBase: (INTERNAL) Spherical base classes `CartesianSphericalBase` and `LatLonSphericalBase`. pygeodesy.sphericalNvector: N-vector-based classes geodetic (lat-/longitude) LatLon, geocentric (ECEF) Cartesian and Nvector and functions areaOf, intersection, meanOf, nearestOn2, triangulate and trilaterate, all spherical. pygeodesy.sphericalTrigonometry: Trigonometric classes geodetic (lat-/longitude) LatLon and geocentric (ECEF) Cartesian and functions areaOf, intersection, isPoleEnclosedBy, meanOf, nearestOn2 and perimeterOf, all spherical. pygeodesy.streprs: Floating point and other formatting utilities. pygeodesy.trf: Terrestrial Reference Frame (TRF) classes RefFrame, registry RefFrames and TRFError. pygeodesy.units: Sub-classes `Float`, `Int` and `Str` from basic `float`, `int` respectively `str` to named units as Degrees, Feet, Meter, Radians, etc. pygeodesy.ups: Universal Polar Stereographic (UPS) classes Ups and UPSError and functions parseUPS5, toUps8 and upsZoneBand5. pygeodesy.utily: Geometric and other utility functions and constants. pygeodesy.utm: Universal Transverse Mercator (UTM) classes Utm and UTMError and functions parseUTM5, toUtm8 and utmZoneBand5. pygeodesy.utmups: Functions parseUTMUPS5, toUtmUps8, UtmUps and utmupsZoneBand5 to handle both Universal Transverse Mercator (UTM) and Universal Polar Stereographic (UPS) coordinates. pygeodesy.utmupsBase: (INTERNAL) Base class `UtmUpsBase` and private functions for the UTM, UPS, Mgrs and Epsg classes/modules. pygeodesy.vector3d: Generic 3-D vector base class Vector3d and function sumOf. pygeodesy.webmercator: Web Mercator (WM) classes Wm and WebMercatorError and functions parseWM and toWm. pygeodesy.wgrs: Classes Georef and WGRSError and several functions to encode, decode and inspect World Geographic Reference System (WGRS) references.

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.
| Georef Georef class, a named `str`.
| WGRSError World Geographic Reference System (WGRS) encode, decode or other Georef issue.
| 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.
| 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`.
| Bearing_ Named `float` representing a bearing in `radians` from compass `degrees`.
| CSSError Cassini-Soldner (CSS) conversion or other Css issue.
| CassiniSoldner Cassini-Soldner projection, a Python version of Karney's C++ class CassiniSoldner.
| ClipError Clip box or clip region issue.
| 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.
| Datum Ellipsoid and transform parameters for an earth model.
| Degrees Named `float` representing a coordinate in `degrees`, optionally clipped.
| Degrees_ Named `Degrees` representing a coordinate in `degrees` with optional limits `low` and `high`.
| Distance Named `float` representing a distance, conventionally in `meter`.
| 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.
| Easting Named `float` representing an easting.
| EcefCartesian Conversion between geodetic `(lat, lon, height)` and local cartesian `(x, y, z)` coordinates with a local cartesian origin at `(lat0, lon0, height0)`, transcribed from Karney's C++ class LocalCartesian.
| EcefError An ECEF or `Ecef*` related issue.
| EcefKarney Conversion between geodetic and geocentric, aka Earth-Centered, Earth-Fixed (ECEF) coordinates based on Karney's 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 transcribed 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 transformations.
| Ellipsoid Ellipsoid with equatorial and polar radius, flattening, inverse flattening and other, often used, cached attributes, supporting spherical and oblate and prolate ellipsoidal models.
| Ellipsoid2 Like Ellipsoid, but specified by equatorial radius and flattening.
| Elliptic Elliptic integrals and functions.
| EllipticError Elliptic integral, function, convergence or other Elliptic issue.
| Equidistant Azimuthal equidistant projection for the sphere**, see Snyder, pp 195-197 and MathWorld-Wolfram.
| 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`.
| Fdot Precision dot product.
| Feet Named `float` representing a distance or length in `feet`.
| Fhorner Precision polynomial evaluation using the Horner form.
| Float Named `float`.
| Float_ Named `float` with optional `low` and `high` limit.
| Fpolynomial Precision polynomial evaluation.
| Frechet Frechet base class, requires method Frechet.distance to be overloaded.
| FrechetCosineAndoyerLambert Compute the `Frechet` distance based on the angular distance in `radians` from function cosineAndoyerLambert_.
| FrechetCosineForsytheAndoyerLambert Compute the `Frechet` distance based on the angular distance in `radians` from function cosineForsytheAndoyerLambert_.
| FrechetCosineLaw Compute the `Frechet` distance based on the angular distance in `radians` from function 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 equirectangular_.
| FrechetError Fréchet issue.
| FrechetEuclidean Compute the `Frechet` distance based on the `Euclidean` distance in `radians` from function euclidean_.
| FrechetFlatLocal Compute the `Frechet` distance based on the angular distance in `radians squared` like function flatLocal_/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 haversine_.
| FrechetHubeny Compute the `Frechet` distance based on the angular distance in `radians squared` like function flatLocal_/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 thomas_.
| FrechetVincentys Compute the `Frechet` distance based on the angular distance in `radians` from function vincentys_.
| Fsum Precision summation similar to standard Python function `math.fsum`.
| 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.
| 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 transcribed 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.
| 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.
| HausdorffCosineAndoyerLambert Compute the `Hausdorff` distance based on the angular distance in `radians` from function cosineAndoyerLambert_.
| HausdorffCosineForsytheAndoyerLambert Compute the `Hausdorff` distance based on the angular distance in `radians` from function cosineForsytheAndoyerLambert_.
| HausdorffCosineLaw Compute the `Hausdorff` distance based on the angular distance in `radians` from function 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 equirectangular_.
| HausdorffError Hausdorff issue.
| HausdorffEuclidean Compute the `Hausdorff` distance based on the `Euclidean` distance in `radians` from function euclidean_.
| HausdorffFlatLocal Compute the `Hausdorff` distance based on the angular distance in `radians squared` like function flatLocal_/hubeny_.
| HausdorffFlatPolar Compute the `Hausdorff` distance based on the angular distance in `radians` from function flatPolar_.
| HausdorffHaversine Compute the `Hausdorff` distance based on the angular distance in `radians` from function haversine_.
| HausdorffHubeny Compute the `Hausdorff` distance based on the angular distance in `radians squared` like function flatLocal_/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 thomas_.
| HausdorffVincentys Compute the `Hausdorff` distance based on the angular distance in `radians` from function 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 cosineAndoyerLambert_.
| HeightIDWcosineForsytheAndoyerLambert Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in `radians` from function cosineForsytheAndoyerLambert_.
| HeightIDWcosineLaw Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in `radians` from function 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 equirectangular_.
| HeightIDWeuclidean Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in `radians` from function euclidean_.
| HeightIDWflatLocal Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in `radians squared` like function flatLocal_/hubeny_.
| HeightIDWflatPolar Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in `radians` from function flatPolar_.
| HeightIDWhaversine Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in `radians` from function haversine_.
| HeightIDWhubeny Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in `radians squared` like function flatLocal_/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 thomas_.
| HeightIDWvincentys Height interpolator using Inverse Distance Weighting (IDW) and the angular distance in `radians` from function 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`.
| IntersectionError Error raised for path or circle intersection issues.
| 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**, see Snyder, pp 185-187 and MathWorld-Wolfram.
| Lat Named `float` representing a latitude in `degrees`.
| LatLon2psxy Wrapper for `LatLon` points as "on-the-fly" pseudo-xy coordinates.
| 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 equirectangular and equirectangular_ and `nearestOn*` and `simplify*` functions or methods.
| Lon Named `float` representing a longitude in `degrees`.
| Lon_ Named `float` representing a longitude in `degrees` within limits `low` and `high`.
| MGRSError Military Grid Reference System (MGRS) parse or other Mgrs issue.
| 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.
| Northing Named `float` representing a northing.
| Number_ Named `int` representing a non-negtive 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`.
| Phi_ Named `float` representing a latitude in `radians` converted from `degrees`.
| PointsError Error for an insufficient number of points.
| Precision_ Named `int` with optional `low` and `high` limits representing a precision.
| Radians Named `float` representing a coordinate in `radians`, optionally clipped.
| 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 clipDegrees, clipRadians, parse3llh, parseDMS, parseDMS2 or parseRad.
| RefFrame Terrestrial Reference Frame (TRF) parameters.
| RefFrameError DEPRECATED, use class TRFError.
| 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.
| Stereographic Stereographic projection for the sphere**, see Snyder, pp 157-160 and MathWorld-Wolfram.
| Str Named `str`.
| TRFError Terrestrial Reference Frame (TRF) or RefFrame conversion issue.
| Transform Helmert transformation.
| 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.
| Vector3d Generic 3-D vector manipulation.
| VectorError Vector3d or `*Nvector` issue.
| WebMercatorError Web Mercator (WM) parser or Wm issue.
| Wm Web Mercator (WM) coordinate.
| Zone Named `int` representing a UTM/UPS zone number.
| a_f2Tuple 2-Tuple `(a, f)` specifying an ellipsoid by equatorial radius (`meter`) and scalar flattening.
| property_RO

Functions
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_b2f(a, b) Return `f`, the 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_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))). |
anStr(name, OKd=`'``._-``'`, sub=`'``_``'`) DEPRECATED, use function 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=_R_M, wrap=True) DEPRECATED, use function areaOf. |
asin1(x) Return math.asin(max(-1, min(1, x))). |
atan2d(y, x) Compute `atan2(y, x)` to `degrees`. |
attrs(inst, *names, **kwds) Get instance attributes as name=value strings, with `float`s handled like 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=`'````'`) Convert bearing to a string. |
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 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) Get the name of the calling callable. |
cbrt(x) Compute the cubic root x**(1/3). |
cbrt2(x) Compute the cubic root squared x**(2/3). |
centroidOf(points, wrap=True, LatLon=None) Determine the centroid of a polygon. |
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) Clip a path against a rectangular clip box using the Cohen-Sutherland algorithm. |
clipDMS(deg, limit) DEPRECATED, use function clipDegrees. |
clipDegrees(deg, limit) Clip a lat- or longitude to the given range. |
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 clips. |
clips(bstr, limit=50, white=`'````'`) Clip a string to the given length limit. |
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=`'````'`) Convert bearing to a string suffixed with compass point. |
compassPoint(bearing, prec=3) Convert bearing to a compass point. |
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. |
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]. |
degrees2m(deg, radius=6371008.77141, lat=0) Convert angle to distance along the equator or along a parallel at an other latitude. |
degrees360(rad) Convert radians to degrees and wrap [0..+360). |
degrees90(rad) Convert radians to degrees and wrap [-270..+90]. |
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 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`...`, name=`'````'`) If Karney's geographiclib package is installed, return 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. |
euclidean(lat1, lon1, lat2, lon2, radius=6371008.77141, adjust=True, wrap=False) Approximate the `Euclidian` 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 or exception chaining setting. |
f2e2(f) Return `e2`, the 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 fstrzs. |
f_2f(f_) Return `f`, the flattening for a given inverse flattening. |
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. |
favg(v1, v2, f=0.5) Return the weighted 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. |
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(iterable, start=1.0) Iterable product, like `math.prod` or `numpy.prod`. |
fractional(points, fi, LatLon=None, **LatLon_kwds) Return the point at a given fractional index. |
frange(start, number, step=1) Generate a range of `float`s. |
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. |
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(iterable) Return an accurate floating point sum of values in the iterable. |
fsum_(*xs) Precision summation of the positional argument vulues. |
ft2m(feet, usurvey=False) Convert International or US Survey feet 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`...`, name=`'````'`) If Karney's geographiclib package is installed, return an GnomonicKarney otherwise an Gnomonic instance. |
halfs2(str2) Split a string in 2 halfs. |
hausdorff_(model, target, both=False, early=True, seed=None, units=`'````'`, distance=None, point=<function _point at 0x7fbd876bb0d0>) 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 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 norm, squared x**2 + y**2. |
hypot3(x, y, z) DEPRECATED, use function hypot_. |
hypot_(*xs) Compute the norm sqrt(sum(xs[i]**2)) for i=0..len(xs). |
inStr(inst, *args, **kwds) DEPRECATED, use function instr. |
instr(inst, *args, **kwds) Return the string representation of an instantiation. |
intersections2(center1, radius1, center2, radius2, sphere=True, Vector=None, **Vector_kwds) Compute the intersection of two spheres or circles, each defined by a 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. |
isclockwise(points, adjust=False, wrap=True) Determine the direction of a path or polygon. |
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 isenclosedBy. |
isfinite(obj) Check for `Inf` and `NaN` values. |
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. |
bool |
isnan(x) Check if float x is not a number (NaN). |
isneg0(obj) Check for NEG0, negative 0.0. |
ispolar(points, wrap=False) Check whether a polygon encloses a pole. |
isscalar(obj) Check for scalar types. |
issequence(obj, *excluded) Check for sequence types. |
isstr(obj) Check for string types. |
issubclassof(Sub, Super) Check whether a class is a sub-class of a super class. |
iterNumpy2(obj) Iterate over Numpy2 wrappers or other sequences exceeding the threshold. |
iterNumpy2over(n=None) Get or set the iterNumpy2 threshold. |
latDMS(deg, form=`'``dms``'`, prec=2, sep=`'````'`) Convert latitude to a string, optionally suffixed with N or S. |
latlon2n_xyz(lat, lon) 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) 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=`'````'`) 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). |
m2degrees(meter, radius=6371008.77141, lat=0) Convert distance to angle along equator or along a parallel at an other latitude. |
m2ft(meter, usurvey=False) Convert meter to International or US Survey feet (`ft`). |
m2km(meter) Convert meter to kilo meter (km). |
map1(func, *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. |
modulename(clas, prefixed=None) Return the class name optionally prefixed with the module name. |
n2e2(n) Return `e2`, the eccentricity squared for a given 3rd flattening. |
n2f(n) Return `f`, the flattening for a given 3rd flattening. |
n_xyz2latlon(x, y, z) Convert `n-vector` components to lat- and longitude in `degrees`. |
n_xyz2philam(x, y, z) Convert `n-vector` components to lat- and longitude in `radians`. |
nameof(inst) Get the name of an instance. |
nearestOn3(point, points, closed=False, wrap=False, **options) DEPRECATED, use function nearestOn5. |
nearestOn4(point, points, closed=False, wrap=False, **options) DEPRECATED, use function nearestOn5. |
nearestOn5(point, points, closed=False, wrap=False, LatLon=None, **options) Locate the point on a path or polygon closest to an other point. |
normDMS(strDMS, norm=`'````'`) Normalize all degree ˚, minute ' and second " symbols in a string to the default symbols %s, %s and %s. |
notImplemented(inst, name, *args, **kwds) Raise a `NotImplementedError` for a missing method or property. |
notOverloaded(inst, name, *args, **kwds) Raise an `AssertionError` for a method or property not overloaded. |
pairs(items, prec=6, fmt=`'``F``'`, ints=False, sep=`'``=``'`) Convert items to name=value strings, with `float`s handled like fstr. |
parse3d(str3d, sep=`'``,``'`, name=`'````'`, Vector=<class 'pygeodesy.vector3d.Vector3d'>, **Vector_kwds) Parse an `"x, y, z"` string. |
parse3llh(strllh, height=0, sep=`'``,``'`, clipLat=90, clipLon=180) Parse a string representing lat-, longitude and optional height. |
parseDDDMMSS(strDDDMMSS, suffix=`'``NSEW``'`, sep=`'````'`, clip=0) Parse a lat- or longitude represention form [D]DDMMSS in degrees. |
parseDMS(strDMS, suffix=`'``NSEW``'`, sep=`'````'`, clip=0) Parse a lat- or longitude represention in degrees. |
parseDMS2(strLat, strLon, sep=`'````'`, clipLat=90, clipLon=180) Parse lat- and longitude representions 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 and northing. |
parseOSGR(strOSGR, Osgr=<class 'pygeodesy.osgr.Osgr'>, name=`'````'`) Parse an OSGR coordinate string to an Osgr instance. |
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=_R_M, Utm=_R_M, 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 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=_R_M, wrap=True) DEPRECATED, use function perimeterOf. |
philam2n_xyz(phi, lam) Convert lat-, longitude to `n-vector` (normal to the earth's surface) X, Y and Z components. |
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. |
property_doc_(doc) Decorator for a property with documentation. |
quadOf(lat1, lon1, lat2, lon2, 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. |
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. |
randomrangenerator(seed) Return a `seed`ed random range function generator. |
rangerrors(raiser=None) Get/set the throwing of RangeErrors. |
reprs(objs, prec=6, fmt=`'``F``'`, ints=False) Convert objects to `repr` strings, with `float`s handled like fstr. |
scalar(value, low=2.22044604925e-16, high=1.0, name=`'``scalar``'`, Error=<type 'exceptions.ValueError'>) DEPRECATED, use class Number_ or Scalar_. |
simplify1(points, distance, radius=6371008.77141, indices=False, **options) Basic simplification of a path of `LatLon` points. |
simplify2(points, pipe, radius=_R_M, shortest=False, indices=False, **options) DEPRECATED, use function simplifyRW. |
simplifyRDP(points, distance, radius=6371008.77141, shortest=False, indices=False, **options) Ramer-Douglas-Peucker (RDP) simplification of a path of `LatLon` points. |
simplifyRDPm(points, distance, radius=6371008.77141, shortest=False, indices=False, **options) Modified Ramer-Douglas-Peucker (RDPm) simplification of a path of `LatLon` points. |
simplifyRW(points, pipe, radius=6371008.77141, shortest=False, indices=False, **options) Reumann-Witkam (RW) simplification of a path of `LatLon` points. |
simplifyVW(points, area, radius=6371008.77141, attr=None, indices=False, **options) Visvalingam-Whyatt (VW) simplification of a path of `LatLon` points. |
simplifyVWm(points, area, 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 angle(s). |
sincos2d(*deg) Return the `sine` and `cosine` of angle(s) in `degrees`. |
splice(iterable, n=2, **fill) Split an iterable into `n` slices. |
sqrt3(x) Compute the square root, cubed sqrt(x)**3 or sqrt(x**3). |
strs(objs, prec=6, fmt=`'``F``'`, ints=False) Convert objects to `str` strings, with `float`s handled like fstr. |
tanPI_2_2(rad) Compute the tangent of half angle, 90 degrees rotated. |
tan_2(rad) Compute the tangent of half angle. |
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. |
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=`'````'`) 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=_R_M, cmoff=True, name=`'````'`) DEPRECATED, use function 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. |
unStr(name, *args, **kwds) DEPRECATED, use function 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. |
unstr(name, *args, **kwds) Return the string representation of an invokation. |
upsZoneBand5(lat, lon, strict=True) 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 utmZoneBand5. |
utmZoneBand5(lat, lon, cmoff=False) 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) 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. |
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]. |

Variables
| pygeodesy_abspath = ``'``..../PyGe``...`` Fully qualified `pygeodesy` directory name (`str`).
| version = ``'``20.9.2``'`` Normalized `PyGeodesy` version (`str`).
| Conics = `Conics.Be08Lb: Conic(name='Be08Lb', lat0=50.797815, l`...`` Registered conics (`enum-like`).
| Datums = `Datums.BD72: Datum(name='BD72', ellipsoid=Ellipsoids.`...`` Registered datums (`enum-like`).
| EPS = `2.22044604925e-16` System's epsilon ≈ 2.2202e-16 (`float`).
| EPS1 = `1.0` 1 - EPS = 0.9999999999999998 (`float`).
| EPS1_2 = `1.0` 1 - EPS_2 = 0.9999999999999999 (`float`).
| EPS2 EPS * 2 = 4.4409e-16 (`float`).
| EPS_2 = `1.11022302463e-16` EPS / 2 ≈ 1.1102e-16 (`float`).
| Ellipsoids = `Ellipsoids.Airy1830: Ellipsoid(name='Airy1830', a`...`` Registered ellipsoids (`enum-like`).
| F_D = ``'``d``'`` Format degrees as unsigned "deg°" plus suffix (`str`).
| F_DEG = ``'``deg``'`` Format degrees as unsigned "[D]DD" plus suffix without symbol (`str`).
| F_DEG_ = ``'``-deg``'`` Format degrees as signed "-/[D]DD" without suffix and symbol (`str`).
| F_DEG__ = ``'``+deg``'`` Format degrees as signed "-/+[D]DD" without suffix and symbol (`str`).
| F_DM = ``'``dm``'`` Format degrees as unsigned "deg°min′" plus suffix (`str`).
| F_DMS = ``'``dms``'`` Format degrees as unsigned "deg°min′sec″" plus suffix (`str`).
| F_DMS_ = ``'``-dms``'`` Format degrees as signed "-/deg°min′sec″" without suffix (`str`).
| F_DMS__ = ``'``+dms``'`` Format degrees as signed "-/+deg°min′sec″" without suffix (`str`).
| F_DM_ = ``'``-dm``'`` Format degrees as signed "-/deg°min′" without suffix (`str`).
| F_DM__ = ``'``+dm``'`` Format degrees as signed "-/+deg°min′" without suffix (`str`).
| F_D_ = ``'``-d``'`` Format degrees as signed "-/deg°" without suffix (`str`).
| F_D__ = ``'``+d``'`` Format degrees as signed "-/+deg°" without suffix (`str`).
| F_MIN = ``'``min``'`` Format degrees as unsigned "[D]DDMM" plus suffix without symbols (`str`).
| F_MIN_ = ``'``-min``'`` Format degrees as signed "-/[D]DDMM" without suffix and symbols (`str`).
| F_MIN__ = ``'``+min``'`` Format degrees as signed "-/+[D]DDMM" without suffix and symbols (`str`).
| F_RAD = ``'``rad``'`` Convert degrees to radians and format as unsigned "RR" plus suffix (`str`).
| F_RAD_ = ``'``-rad``'`` Convert degrees to radians and format as signed "-/RR" without suffix (`str`).
| F_RAD__ = ``'``+rad``'`` Convert degrees to radians and format as signed "-/+RR" without suffix (`str`).
| F_SEC = ``'``sec``'`` Format degrees as unsigned "[D]DDMMSS" plus suffix without symbols (`str`).
| F_SEC_ = ``'``-sec``'`` Format degrees as signed "-/[D]DDMMSS" without suffix and symbols (`str`).
| F_SEC__ = ``'``+sec``'`` Format degrees as signed "-/+[D]DDMMSS" without suffix and symbols (`str`).
| F__E = ``'``e``'`` Format degrees as unsigned "%E" plus suffix without symbol (`str`).
| F__E_ = ``'``-e``'`` Format degrees as signed "-%E" without suffix and symbol (`str`).
| F__E__ = ``'``+e``'`` Format degrees as signed "-/+%E" without suffix and symbol (`str`).
| F__F = ``'``f``'`` Format degrees as unsigned "%F" plus suffix without symbol (`str`).
| F__F_ = ``'``-f``'`` Format degrees as signed "-%F" without suffix and symbol (`str`).
| F__F__ = ``'``+f``'`` Format degrees as signed "-/+%F" without suffix and symbol (`str`).
| F__G = ``'``g``'`` Format degrees as unsigned "%G" plus suffix without symbol (`str`).
| F__G_ = ``'``-g``'`` Format degrees as signed "-%G" without suffix and symbol (`str`).
| F__G__ = ``'``+g``'`` Format degrees as signed "-/+%G" without suffix and symbol (`str`).
| INF = `inf` Infinity (`float`), see function `isinf`, `isfinite`.
| MANTIS = `53` System's 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 `isnan`.
| NEG0 = `-0.0` Negative 0.0 (`float`), see function `isneg0`.
| NN = ``'````'`` Empty (`str`), Nomen Nescio.
| OK = ``'``OK``'``
| PI = `3.14159265359` Constant math.pi (`float`).
| PI2 = `6.28318530718` Two PI, math.pi * 2 (`float`).
| PI_2 = `1.57079632679` Half PI, math.pi / 2 (`float`).
| PI_4 = `0.785398163397` Quarter PI, PI / 4 (`float`).
| R_FM = `6371000.0` Former FAI Sphere earth radius (`meter`).
| R_KM = `6371.008771415` Mean (spherical) earth radius (`km`, kilometer).
| R_M = `6371008.771415` Mean (spherical) earth radius (`meter`).
| R_MA = `6378137.0` Major (equatorial) earth radius (`meter`) WGS84, EPSG:3785.
| R_MB = `6356752.0` Minor (polar) earth radius (`meter`) WGS84, EPSG:3785.
| R_NM = `3440.06953446921` Mean (spherical) earth radius (`NM`, nautical miles).
| R_SM = `3958.753395372691` Mean (spherical) earth radius (`SM`, statute miles).
| R_VM = `6366707.0194937` Aviation/Navigation earth radius (`meter`).
| RefFrames = `RefFrames.ETRF2000: RefFrame(name='ETRF2000', epoc`...`` Registered reference frames (`enum-like`).
| S_DEG = ``'``°``'`` Degrees symbol "°" (`str`).
| S_MIN = ``'``\xe2\x80\xb2``'`` Minutes symbol "′" (`str`).
| S_RAD = ``'````'`` Radians symbol "" (`str`).
| S_SEC = ``'``″``'`` Seconds symbol "″" (`str`).
| S_SEP = ``'````'`` Separator between deg°, min′ and sec″ "" (`str`).
| Transforms = `Transforms.BD72: Transform(name='BD72', tx=106.86`...`` Registered transforms (`enum-like`).
| isLazy = `None` hash(x)

Function Details

### 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 (longitudinal) zone with/-out Band letter for UTM or for UPS zone `"00"` or `0` (`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) Band letter `'C'|'D'..'W'|'X'` or UPS (polar) Band letter `'A'|'B'|'Y'|'Z'` (`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 B({`datum`}. `UTMUPSError` - UTM or UPS validation failed. See Also: Classes Utm and Ups and Karney's UTMUPS.

### a_b2f (a, b) |
Return `f`, the flattening for a given equatorial and polar radius. Arguments: `a` - Equatorial (major) radius (`scalar` > 0). `b` - Polar (minor) radius (`scalar` > 0). Returns: The flattening (`float` or `0`).

### a_b2f_ (a, b) |
Return `f_`, the inverse flattening for a given equatorial and polar radius. Arguments: `a` - Equatorial (major) radius (`scalar` > 0). `b` - Polar (minor) radius (`scalar` > 0). Returns: The inverse flattening (`float` or `0`).

### a_f2b (a, f) |
Return `b`, the polar radius for a given equatorial radius and flattening. Arguments: `a` - Equatorial (major) radius (`scalar` > 0). `f` - Flattening (`scalar` < 1). Returns: The polar (minor) radius (`float`).

### a_f_2b (a, f_) |
Return `b`, the polar radius for a given equatorial radius and inverse flattening. Arguments: `a` - Equatorial (major) radius (`scalar` > 0). `f_` - Inverse flattening (`scalar` >>> 1). Returns: The polar (minor) radius (`float`).

### 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 and 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`). `wrap` - Wrap lat-, wrap and unroll longitudes (`bool`). Returns: Approximate area (`meter`, same units as `radius`, squared). 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.

### atan2d (y, x) |
Compute `atan2(y, x)` to `degrees`. See Also: Karney's C++ function Math.atan2d.

### attrs (inst, *names, **kwds) |
Get instance attributes as name=value strings, with `float`s handled like fstr. Arguments: `inst` - The instance (any `type`). `names` - The attribute names (`str`s). `kwds` - Keyword argument for function pairs, except `Nones=True` to in-/exclude missing or attributes with a `None` value. Returns: A `tuple(sep.join(t) for t in zip(names, reprs(values, ...)))` of `str`s.

### b_f2a (b, f) |
Return `a`, the equatorial radius for a given polar radius and flattening. Arguments: `b` - Polar (minor) radius (`scalar` > 0). `f` - Flattening (`scalar` < 1). Returns: The equatorial (major) radius (`float`).

### b_f_2a (b, f_) |
Return `a`, the equatorial radius for a given polar radius and inverse flattening. Arguments: `b` - Polar (minor) radius (`scalar` > 0). `f_` - Inverse flattening (`scalar` >>> 1). Returns: The equatorial (major) radius (`float`).

### 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 bearing_. Returns: Initial or final bearing (compass `degrees360`) or zero if start and end point coincide.

### bearingDMS (bearing, form=`'``d``'`, prec=None, sep=`'````'`) |
Convert bearing to a string. Arguments: `bearing` - Bearing from North (compass `degrees360`). `form` - Optional `bearing` format (`str` or F_D, F_DM, F_DMS, F_DEG, F_MIN, F_SEC, F__E, F__F, F__G, F_RAD, F_D_, F_DM_, F_DMS_, F_DEG_, F_MIN_, F_SEC_, F__E_, F__F_, F__G_, F_RAD_, F_D__, F_DM__, F_DMS__, F_DEG__, F_MIN__, F_SEC__, F__E__, F__F__, F__G__ or F_RAD__). `prec` - Optional 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`. `sep` - Optional separator (`str`). Returns: Compass degrees per the specified `form` (`str`). 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 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 boundsOf. Returns: 2-Tuple `(latlonSW, latlonNE)` as `LatLon` or 4-Tuple `(latS, lonW, latN, lonE)` if `LatLon` is `None`.

### 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 `LatLon`s if `LatLon` is `None` a Bounds4Tuple`(latS, lonW, latN, lonE)`. Raises: `PointsError` - Insufficient number of `points` `TypeError` - Some `points` are not `LatLon`. 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) |
Get the name of the calling callable. Arguments: `up` - Number of call stack frames up (`int`). `dflt` - Default return value (`any`). `source` - Include source file name and line number (`bool`). Returns: Name of the non-internal callable (`str`) or `dflt` if none found.

### cbrt (x) |
Compute the cubic root x**(1/3). Arguments: `x` - Value (`scalar`). Returns: Cubic root (`float`). See Also: Functions cbrt2 and sqrt3.

### cbrt2 (x) |
Compute the cubic root squared x**(2/3). Arguments: `x` - Value (`scalar`). Returns: Cubic 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 location (`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 Calculating The Area And Centroid Of A Polygon.

### 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) |
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 ClipCS3Tuple`(start, end, index)` for each edge of the clipped path. Raises: `ClipError` - The `lowerleft` and `upperright` corners specify an invalid clip box. `PointsError` - Insufficient number of `points`.

### clipDegrees (deg, limit) |
Clip a lat- or longitude to the given range. Arguments: `deg` - Unclipped lat- or longitude (`degrees`). `limit` - Valid `-limit..+limit` range (`degrees`). Returns: Clipped value (`degrees`). Raises: `RangeError` - If `abs(deg)` beyond `limit` and rangerrors set to `True`.

### clipRadians (rad, limit) |
Clip a lat- or longitude to the given range. Arguments: `rad` - Unclipped lat- or longitude (`radians`). `limit` - Valid `-limit..+limit` range (`radians`). Returns: Clipped value (`radians`). Raises: `RangeError` - If `abs(rad)` beyond `limit` and rangerrors set to `True`.

### 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`.

### 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`.

### 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, non-near-polar vectors up to a few hundred Km or Miles. Use function 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 unroll180 longitudes (`bool`). Returns: Compass angle from North (`degrees360`). Note: Courtesy Martin Schultz. See Also: Local, flat earth approximation.

### compassDMS (bearing, form=`'``d``'`, prec=None, sep=`'````'`) |
Convert bearing to a string suffixed with compass point. Arguments: `bearing` - Bearing from North (compass `degrees360`). `form` - Optional `bearing` format (`str` or F_D, F_DM, F_DMS, F_DEG, F_MIN, F_SEC, F__E, F__F, F__G, F_RAD, F_D_, F_DM_, F_DMS_, F_DEG_, F_MIN_, F_SEC_, F__E_, F__F_, F__G_, F_RAD_, F_D__, F_DM__, F_DMS__, F_DEG__, F_MIN__, F_SEC__, F__E__, F__F__, F__G__ or F_RAD__). `prec` - Optional 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`. `sep` - Optional separator (`str`). Returns: Compass degrees and point in the specified form (`str`).

### compassPoint (bearing, prec=3) |
Convert bearing to a compass point. Arguments: `bearing` - Bearing from North (compass `degrees360`). `prec` - Optional precision (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'

### 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` - Ellipsoidal datum to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple). `wrap` - Wrap and unroll180 longitudes (`bool`). Returns: Distance (`meter`, same units as the `datum`'s ellipsoid axes). Raises: `TypeError` - Invalid `datum`. See Also: Functions cosineAndoyerLambert_, cosineForsytheAndoyerLambert, cosineLaw, equirectangular, euclidean, flatLocal/hubeny, flatPolar, haversine, thomas and vincentys and method Ellipsoid.distance2.

### 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` - Ellipsoidal datum to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple). Returns: Angular distance (`radians`). Raises: `TypeError` - Invalid `datum`. See Also: Functions cosineAndoyerLambert, cosineForsytheAndoyerLambert_, cosineLaw_, equirectangular_, euclidean_, flatLocal_/hubeny_, flatPolar_, haversine_, thomas_ and vincentys_ and Geodesy-PHP.

### 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` - Ellipsoidal datum to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple). `wrap` - Wrap and unroll180 longitudes (`bool`). Returns: Distance (`meter`, same units as the `datum`'s ellipsoid axes). Raises: `TypeError` - Invalid `datum`. See Also: Functions cosineForsytheAndoyerLambert_, cosineAndoyerLambert, cosineLaw, equirectangular, euclidean, flatLocal/hubeny, flatPolar, haversine, thomas and vincentys and method Ellipsoid.distance2.

### 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` - Ellipsoidal datum to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple). Returns: Angular distance (`radians`). Raises: `TypeError` - Invalid `datum`. See Also: Functions cosineForsytheAndoyerLambert, cosineAndoyerLambert_, cosineLaw_, equirectangular_, euclidean_, flatLocal_/hubeny_, flatPolar_, haversine_, thomas_ and vincentys_ and Geodesy-PHP.

### 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 (`meter`). `wrap` - Wrap and unroll180 longitudes (`bool`). Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - Invalid `radius`. See Also: Functions cosineLaw_, cosineAndoyerLambert, cosineForsytheAndoyerLambert, equirectangular, euclidean, flatLocal/hubeny, flatPolar, haversine, thomas and vincentys and method Ellipsoid.distance2. Note: See note at function vincentys_.

### 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`). See Also: Functions cosineLaw, cosineAndoyerLambert_, cosineForsytheAndoyerLambert_, equirectangular_, euclidean_, flatLocal_/hubeny_, flatPolar_, haversine_, thomas_ and vincentys_. Note: See note at function vincentys_.

### 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.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)`

### 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`). `prec` - Optional 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` - Symbol for degrees (`str`). `s_M` - Symbol for minutes (`str`) or `""`. `s_S` - Symbol for seconds (`str`) or `""`. `neg` - Optional sign for negative (`'-'`). `pos` - Optional sign for positive (`''`). Returns: Either degrees, minutes or seconds (`str`).

### degrees180 (rad) |
Convert radians to degrees and wrap [-180..+180]. Arguments: `rad` - Angle (`radians`). Returns: Angle in degrees, wrapped (`degrees180`).

### degrees2m (deg, radius=6371008.77141, lat=0) |
Convert angle to distance along the equator or along a parallel at an other latitude. Arguments: `deg` - Angle (`degrees`). `radius` - Mean earth radius (`meter`). `lat` - Parallel latitude (`degrees90`, `str`). Returns: Distance (`meter`, same units as `radius`). Raises: `RangeError` - Latitude `lat` outside valid range and rangerrors set to `True`. `ValueError` - Invalid `deg`, `radius` or `lat`. See Also: Function m2degrees.

### degrees360 (rad) |
Convert radians to degrees and wrap [0..+360). Arguments: `rad` - Angle (`radians`). Returns: Angle in degrees, wrapped (`degrees360`).

### degrees90 (rad) |
Convert radians to degrees and wrap [-270..+90]. Arguments: `rad` - Angle (`radians`). Returns: Angle in degrees, wrapped (`degrees90`).

### 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: `GeoidError` - Invalid `GeoidHeights_dat`. 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-, Type-, URL-` or `ValueError` as a string (`str`). See Also: USGS National Map, the FAQ, geoid.py, module geoids, classes GeoidG2012B, GeoidKarney and GeoidPGM.

### encodeEPSG (zone, hemipole=`'````'`, band=`'````'`) |
DEPRECATED, use function epsg.encode. Returns: `EPSG` code (`int`).

### 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`). `extras` - Optional leading items (`str`s). 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)`. 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`...`, name=`'````'`) |
If Karney's geographiclib package is installed, return 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`). `name` - Optional name for the projection (`str`). Returns: An EquidistantKarney or Equidistant instance. Raises: `AzimuthalError` - Invalid `lat0`, `lon0` or sperical `datum`. `TypeError` - Invalid `datum`.

### 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 (`meter`). `options` - Optional keyword arguments for function equirectangular_. Returns: Distance (`meter`, same units as `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)`.

### 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 unroll180 longitudes (`bool`). Returns: A Distance4Tuple`(distance2, delta_lat, delta_lon, unroll_lon2)`. Raises: `LimitError` - If the lat- and/or longitudinal delta exceeds the `-limit..+limit` range and limiterrors set to `True`. See Also: Local, flat earth approximation, functions equirectangular, cosineAndoyerLambert, cosineForsytheAndoyerLambert, cosineLaw, euclidean, flatLocal/hubeny, flatPolar, haversine, thomas and vincentys and methods Ellipsoid.distance2, `LatLon.distanceTo*` and `LatLon.equirectangularTo`.

### euclidean (lat1, lon1, lat2, lon2, radius=6371008.77141, adjust=True, wrap=False) |
Approximate the `Euclidian` 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 (`meter`). `adjust` - Adjust the longitudinal delta by the cosine of the mean latitude (`bool`). `wrap` - Wrap and unroll180 longitudes (`bool`). Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - Invalid `radius`. See Also: Distance between two (spherical) points, functions euclidean_, cosineAndoyerLambert, cosineForsytheAndoyerLambert, cosineLaw, equirectangular, flatLocal/hubeny, flatPolar, haversine, thomas and vincentys and methods Ellipsoid.distance2, `LatLon.distanceTo*` and `LatLon.equirectangularTo`.

### 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`). See Also: Functions euclidean, cosineAndoyerLambert_, cosineForsytheAndoyerLambert_, cosineLaw_, equirectangular_, flatLocal_/hubeny_, flatPolar_, haversine_, thomas_ and vincentys_.

### exception_chaining (error=None) |
Get the previous exception or exception chaining setting. Arguments: `error` - An error instance (`Exception`) or `None`. Returns: If `error=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.

### f2e2 (f) |
Return `e2`, the eccentricity squared for a given flattening. Arguments: `f` - Flattening (`scalar` < 1). Returns: The (1st) eccentricity squared (`float` < 1). Note: The result `e2` will be negative for prolate ellipsoids. See Also: Eccentricity conversions and Flattening.

### f2e22 (f) |
Return `e22`, the 2nd eccentricity squared for a given flattening. Arguments: `f` - Flattening (`scalar` < 1). Returns: The 2nd eccentricity squared (`float` > -1 or `INF`). See Also: Eccentricity conversions.

### f2e32 (f) |
Return `e32`, the 3rd eccentricity squared for a given flattening. Arguments: `f` - Flattening (`scalar` < 1). Returns: The 3rd eccentricity squared (`float`). See Also: Eccentricity conversions.

### f2f2 (f) |
Return `f2`, the 2nd flattening for a given flattening. Arguments: `f` - Flattening (`scalar` < 1). Returns: The 2nd flattening (`float` or `INF`). See Also: Eccentricity conversions and Flattening.

### f2f_ (f) |
Return `f_`, the inverse flattening for a given flattening. Arguments: `f` - Flattening (`scalar` < 1). Returns: The inverse flattening (`float` or `0`).

### f2n (f) |
Return `n`, the 3rd flattening for a given flattening. Arguments: `f` - Flattening (`scalar` < 1). Returns: The 3rd flattening (-1 < `float` < 1). See Also: Eccentricity conversions and Flattening.

### f_2f (f_) |
Return `f`, the flattening for a given inverse flattening. Arguments: `f_` - Inverse flattening (`scalar` >>> 1). Returns: The flattening (`float` or `0`).

### 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`). Raises: `Error` - Invalid or negative `name=value`.

### favg (v1, v2, f=0.5) |
Return the weighted 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` - List, sequence, tuple, etc. (`scalar`s). `b` - All positional arguments (`scalar`s). Returns: Dot product (`float`). Raises: `ValueError` - Unequal `len`(`a`) and `len`(`b`). See Also: Class Fdot.

### 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` - List, sequence, tuple, etc. (`scalar`[]). `b` - List, sequence, tuple, etc. (`scalar`[]). `c` - List, sequence, tuple, etc. (`scalar`[]). `start` - Optional bias (`scalar`). Returns: Dot product (`float`). Raises: `OverflowError` - Partial `2sum` overflow. `ValueError` - Unequal `len``(``a``)`, `len``(``b``)` and/or `len``(``c``)`.

### 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 (`scalar`[]). 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 (`scalar`[]). `ds` - Non-negative distances (`scalar`[]). `beta` - Inverse distance power (`int`, 0, 1, 2, or 3). Returns: Interpolated value `x` (`float`). Raises: `ValueError` - Invalid `beta`, negative `ds` value, weighted `ds` below EPS or unequal `len``(``ds``)` and `len``(``xs``)`. 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` - Ellipsoidal datum to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple). `wrap` - Wrap and 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_/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` - Ellipsoidal datum 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/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 (`meter`). `wrap` - Wrap and unroll180 longitudes (`bool`). Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - Invalid `radius`. See Also: Functions flatPolar_, cosineAndoyerLambert, cosineForsytheAndoyerLambert,cosineLaw, flatLocal/hubeny, equirectangular, euclidean, haversine, thomas and vincentys.

### 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`). See Also: Functions flatPolar, cosineAndoyerLambert_, cosineForsytheAndoyerLambert_, cosineLaw_, equirectangular_, euclidean_, flatLocal_/hubeny_, haversine_, thomas_ and vincentys_.

### fmean (xs) |
Compute the accurate mean sum(xs[i] for i=0..len(xs)) / len(xs). Arguments: `xs` - Values (`scalar`s). 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 (`scalar`[]). 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` (`float`[]). Raises: `TypeError` - Non-scalar `x` or `n` not `int`. `ValueError` - Non-finite `x` or non-positive `n`.

### fprod (iterable, start=1.0) |
Iterable product, like `math.prod` or `numpy.prod`. Arguments: `iterable` - Values to be multiplied (`scalar`[]). `start` - Initial product, also the value returned for an empty iterable (`scalar`). Returns: The product (`float`). See Also: NumPy.prod.

### fractional (points, fi, LatLon=None, **LatLon_kwds) |
Return the point at a given fractional index. Arguments: `points` - The points (`LatLon`[], Numpy2LatLon[], Tuple2LatLon[] or `other`[]). `fi` - The fractional index (`float` or `int`). `LatLon` - Optional class to return the intermediate, fractional point (`LatLon`) or `None`. `LatLon_kwds` - Optional `LatLon` keyword arguments, ignored of `LatLon=None`. Returns: A `LatLon` or if `LatLon` is `None`, a LatLon2Tuple`(lat, lon)` for `points[fi]` if fractional index `fi` is `int`, otherwise the intermediate point between `points[int(fi)]` and `points[int(fi) + 1]` for `float` fractional index `fi`. Raises: `IndexError` - Fractional index `fi` invalid or `points` not subscriptable.

### frange (start, number, step=1) |
Generate a range of `float`s. Arguments: `start` - First value (`float`). `number` - The number of `float`s to generate (`int`). `step` - Increment value (`float`). Returns: A generator (`float`s). 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, name of the distance units (`str`). Returns: A Frechet6Tuple`(fd, fi1, fi2, r, n, units)` where `fi1` and `fi2` are type `int` indices into `points1` respectively `points2`. Raises: `FrechetError` - Insufficient number of `points1` or `points2`. `RecursionError` - Recursion depth exceeded, see sys.getrecursionlimit(). `TypeError` - If `distance` is not a callable. 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

### 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. (`scalar`s). `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 (`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 (iterable) |
Return an accurate floating point sum of values in the iterable. Assumes IEEE-754 floating point arithmetic.

### fsum_ (*xs) |
Precision summation of the positional argument vulues. Arguments: `xs` - Values to be added (`scalar`[]). Returns: Accurate fsum (`float`). Raises: `OverflowError` - Partial `2sum` overflow. `TypeError` - Non-scalar `xs` value. `ValueError` - Invalid or non-finite `xs` value.

### ft2m (feet, usurvey=False) |
Convert International or US Survey feet to meter. Arguments: `feet` - Value in feet (`scalar`). `usurvery` - Convert US Survey feet (`bool`), International feet otherwise. Returns: Value in `meter` (`float`). Raises: `ValueError` - Invalid `feet`.

### 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-, Type-, URL-` or `ValueError` 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`...`, name=`'````'`) |
If Karney's geographiclib package is installed, return an GnomonicKarney otherwise an 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`). `name` - Optional name for the projection (`str`). Returns: An GnomonicKarney or Gnomonic instance. Raises: `AzimuthalError` - Invalid `lat0`, `lon0` or sperical `datum`. `TypeError` - Invalid `datum`.

### 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`).

### hausdorff_ (model, target, both=False, early=True, seed=None, units=`'````'`, distance=None, point=<function _point at 0x7fbd876bb0d0>) |
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, name of the distance units (`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 (`meter`). `wrap` - Wrap and 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`). See Also: Functions haversine, cosineAndoyerLambert_, cosineForsytheAndoyerLambert_, cosineLaw_, equirectangular_, euclidean_, flatLocal_/hubeny_, flatPolar_, thomas_ and vincentys_. Note: See note at function vincentys_.

### heightOf (angle, distance, radius=6371008.77141) |
Determine the height above the (spherical) earth 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`. See Also: MultiDop geog_lib.GeogBeamHt (Shapiro et al. 2009, JTECH and Potvin et al. 2012, JTECH).

### 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 (`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` - Ellipsoidal datum to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple). `wrap` - Wrap and 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_/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` - Ellipsoidal datum 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/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 norm, squared x**2 + y**2. Arguments: `x` - Argument (`scalar`). `y` - Argument (`scalar`). Returns: `x``**2 +` `y``**2` (`float`).

### hypot_ (*xs) |
Compute the norm sqrt(sum(xs[i]**2)) for i=0..len(xs). Arguments: `xs` - X arguments, positional (`scalar`[]). Returns: Norm (`float`). Raises: `OverflowError` - Partial `2sum` overflow. `ValueError` - Invalid or no `xs` value. See Also: Similar to Python 3.8+ math.hypot, but handling of exceptions, `nan` and `infinite` values is different. Note: The Python 3.8+ math.dist Euclidian distance 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) |
Return the string representation of an instantiation. Arguments: `inst` - The instance (any `type`). `args` - Optional positional arguments. `kwds` - Optional keyword arguments. Returns: Representation (`str`).

### intersections2 (center1, radius1, center2, radius2, sphere=True, Vector=None, **Vector_kwds) |
Compute the intersection of two spheres or circles, each defined by a center point and a radius. Arguments: `center1` - Center of the first sphere or circle (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 (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` - Class to return intersections (Vector3d or `Vector3Tuple`) or `None` for Vector3d. `Vector_kwds` - Optional, additional `Vector` keyword arguments, ignored if `Vector=None`. Returns: 2-Tuple of the `center` and `radius` of the intersection of the spheres if `sphere` is `True`. The `radius` is `0.0` for abutting spheres. Otherwise, a 2-tuple of the intersection points of two circles. For abutting circles, both intersection points are the same `Vector` instance. Raises: `IntersectionError` - Concentric, invalid or non-intersecting spheres or circles. `UnitError` - Invalid `radius1` or `radius2`. See Also: Sphere-Sphere and circle-circle intersections.

### 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.

### 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

### 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: sphericalNvector.LatLon.isenclosedBy, sphericalTrigonometry.LatLon.isenclosedBy and MultiDop GeogContainPt (Shapiro et al. 2009, JTECH and Potvin et al. 2012, JTECH).

### isfinite (obj) |
Check for `Inf` and `NaN` values. Arguments: `obj` - Value (`scalar`). Returns: `False` if `obj` is `INF` 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` - Optionally, check `float` type and value (`bool`). Returns: `True` if `obj` is `int` or an integer `float`, `False` otherwise.

### isneg0 (obj) |
Check for NEG0, negative 0.0. Arguments: `obj` - Value (`scalar`). Returns: `True` if `obj` is `NEG0` or -0.0, `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, *excluded) |
Check for sequence types. Arguments: `obj` - The object (any `type`). `excluded` - Optional exclusions (`type`). 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, Super) |
Check whether a class is a sub-class of a super class. Arguments: `Sub` - The sub-class (`class`). `Super` - The super class (`class`). Returns: `True` if `Sub` is a sub-class of `Super`, `False` otherwise (`bool`).

### 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`.

### latDMS (deg, form=`'``dms``'`, prec=2, sep=`'````'`) |
Convert latitude to a string, optionally suffixed with N or S. Arguments: `deg` - Latitude to be formatted (`degrees`). `form` - Optional `deg` format (`str` or F_D, F_DM, F_DMS, F_DEG, F_MIN, F_SEC, F__E, F__F, F__G, F_D_, F_RAD, F_D_, F_DM_, F_DMS_, F_DEG_, F_MIN_ F_SEC_, F__E_, F__F_, F__G_, F_RAD_, F_D__, F_DM__, F_DMS__, F_DEG__, F_MIN__, F_SEC__, F__E__, F__F__, F__G__ or F_RAD__). `prec` - Optional 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`. `sep` - Optional separator (`str`). Returns: Degrees in the specified form (`str`). JS name: toLat.

### latlon2n_xyz (lat, lon) |
Convert lat-, longitude to `n-vector` (normal to the earth's surface) X, Y and Z components. Arguments: `lat` - Latitude (`degrees`). `lon` - Longitude (`degrees`). 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) |
Convert one or more `LatLon` instances to strings. Arguments: `lls` - Single or a list, sequence, tuple, etc. (`LatLon`s). `form` - Optional `deg` format (`str` or F_D, F_DM, F_DMS, F_DEG, F_MIN, F_SEC, F__E, F__F, F__G, F_RAD, F_D_, F_DM_, F_DMS_, F_DEG_, F_MIN_, F_SEC_, F__E_, F__F_, F__G_, F_RAD_, F_D__, F_DM__, F_DMS__, F_DEG__, F_MIN__, F_SEC__, F__E__, F__F__, F__G__ or F_RAD__). `prec` - Optional 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`. `sep` - Separator joining `lls` (`str` or `None`). Returns: A `str` or `tuple` of `sep` is `None` or `NN`.

### 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=`'````'`) |
Convert longitude to a string, optionally suffixed with E or W. Arguments: `deg` - Longitude to be formatted (`degrees`). `form` - Optional `deg` format (`str` or F_D, F_DM, F_DMS, F_DEG, F_MIN, F_SEC, F__E, F__F, F__G, F_RAD, F_D_, F_DM_, F_DMS_, F_DEG_, F_MIN_, F_SEC_, F__E_, F__F_, F__G_, F_RAD_, F_D__, F_DM__, F_DMS__, F_DEG__, F_MIN__, F_SEC__, F__E__, F__F__, F__G__ or F_RAD__). `prec` - Optional 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`. `sep` - Optional separator (`str`). Returns: Degrees in the specified form (`str`). 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: Yield 4 or 5 `LatLon` instances outlining the lune shape. See Also: Latitude-longitude quadrangle.

### 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`.

### m2degrees (meter, radius=6371008.77141, lat=0) |
Convert distance to angle along equator or along a parallel at an other latitude. Arguments: `meter` - Distance (`meter`, same units as `radius`). `radius` - Mean earth radius (`meter`). `lat` - Parallel latitude (`degrees90`, `str`). Returns: Angle (`degrees`). Raises: `RangeError` - Latitude `lat` outside valid range and rangerrors set to `True`. `ValueError` - Invalid `meter`, `radius` or `lat`. See Also: Function degrees2m.

### m2ft (meter, usurvey=False) |
Convert meter to International or US Survey feet (`ft`). Arguments: `meter` - Value in meter (`scalar`). `usurvery` - Convert to US Survey feet (`bool`), International feet otherwise. Returns: Value in `feet` (`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`.

### map1 (func, *xs) |
Apply each argument to a single-argument function and return a `tuple` of results. Arguments: `func` - 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 Python 2 behavior. Arguments: `func` - Function to apply (`callable`). `xs` - Arguments to apply (`list, tuple, ...`). Returns: Function results (`tuple`).

### 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 eccentricity squared for a given 3rd flattening. Arguments: `n` - The 3rd flattening (-1 < `scalar` < 1). Returns: The (1st) eccentricity squared (`float` or -INF). Note: The result `e2` will be negative for prolate 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 -INF). See Also: Eccentricity conversions and Flattening.

### n_xyz2latlon (x, y, z) |
Convert `n-vector` components to lat- and longitude in `degrees`. Arguments: `x` - X component (`scalar`). `y` - Y component (`scalar`). `z` - Z component (`scalar`). Returns: A LatLon2Tuple`(lat, lon)`. See Also: Function n_xyz2philam.

### n_xyz2philam (x, y, z) |
Convert `n-vector` components to lat- and longitude in `radians`. Arguments: `x` - X component (`scalar`). `y` - Y component (`scalar`). `z` - Z component (`scalar`). 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 `""`.

### nearestOn3 (point, points, closed=False, wrap=False, **options) |
DEPRECATED, use function nearestOn5. Returns: 3-Tuple `(lat, lon, distance)`

### nearestOn4 (point, points, closed=False, wrap=False, **options) |
DEPRECATED, use function nearestOn5. Returns: 4-Tuple `(lat, lon, distance, angle)`

### nearestOn5 (point, points, closed=False, wrap=False, LatLon=None, **options) |
Locate the point on a path or polygon closest to an other point. If the given point is within the extent of a polygon edge, the closest point is on that edge, otherwise the closest point is the nearest of that edge's end points. Distances are approximated by function equirectangular_, subject to the supplied `options`. Arguments: `point` - The other, reference point (`LatLon`). `points` - The path or polygon points (`LatLon`[]). `closed` - Optionally, close the path or polygon (`bool`). `wrap` - Wrap and unroll180 longitudes and longitudinal delta (`bool`) in function equirectangular_. `LatLon` - Optional class to return the closest point (`LatLon`) or `None`. `options` - Other keyword arguments for function 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 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 compassAngle. Raises: `LimitError` - Lat- and/or longitudinal delta exceeds the `limit`, see function equirectangular_. `PointsError` - Insufficient number of `points` `TypeError` - Some `points` are not `LatLon`. See Also: Function degrees2m to convert `degrees` to `meter`.

### normDMS (strDMS, norm=`'````'`) |
Normalize all degree ˚, minute ' and second " symbols in a string to the default symbols %s, %s and %s. Arguments: `strDMS` - DMS (`str`). `norm` - Optional replacement symbol, default symbol otherwise (`str`). Returns: Normalized DMS (`str`).

### notImplemented (inst, name, *args, **kwds) |
Raise a `NotImplementedError` for a missing method or property. Arguments: `inst` - Instance (`any`). `name` - Method, property or name (`str` or `callable`). `args` - Method or property positional arguments (any `type`s). `kwds` - Method or property keyword arguments (any `type`s).

### notOverloaded (inst, name, *args, **kwds) |
Raise an `AssertionError` for a method or property not overloaded. Arguments: `inst` - Instance (`any`). `name` - Method, property or name (`str` or `callable`). `args` - Method or property positional arguments (any `type`s). `kwds` - Method or property keyword arguments (any `type`s).

### pairs (items, prec=6, fmt=`'``F``'`, ints=False, sep=`'``=``'`) |
Convert items to name=value strings, with `float`s handled like fstr. Arguments: `items` - Name-value pairs (`dict` or 2-{tuple}s of any `type`s). `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 (`bool`). `sep` - Separator joining names and values (`str`). Returns: A `tuple(sep.join(t) for t in zip(names, reprs(values,...)))` of `str`s.

### parse3d (str3d, sep=`'``,``'`, name=`'````'`, 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`). `name` - Optional instance name (`str`). `Vector` - Optional class (Vector3d). `Vector_kwds` - Optional `Vector` keyword arguments, ignored if `Vector=None`. Returns: New `Vector` or if `Vector` is `None`, a Vector3Tuple`(x, y, z)`. Raises: `VectorError` - Invalid `str3d`.

### parse3llh (strllh, height=0, sep=`'``,``'`, clipLat=90, clipLon=180) |
Parse a string representing lat-, longitude and optional height. 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 (`str`). `clipLat` - Keep latitude in `-clipLat..+clipLat` (`degrees`). `clipLon` - Keep longitude in `-clipLon..+clipLon` range (`degrees`). Returns: A LatLon3Tuple`(lat, lon, height)` in `degrees`, `degrees` and `float`. Raises: `RangeError` - Lat- or longitude value of `strllh` outside valid range and rangerrors set to `True`. `ValueError` - Invalid `strllh` or `height`. Note: See the Notes at function parseDMS. See Also: Functions parseDDDMMSS, parseDMS and parseDMS2. 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) |
Parse a lat- or longitude represention form [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" (''). `clip` - Optionally, limit value to -clip..+clip (`degrees`). Returns: Degrees (`float`). Raises: `ParseError` - Invalid `strDDDMMSS` or `clip` or the `strDDDMMSS` form is incompatible with the suffixed or `suffix` compass point. `RangeError` - Value of `strDDDMMSS` outside the valid range and rangerrors set to `True`. Notes: Type `str` values "[D]DD", "[D]DDMM" and "[D]DDMMSS" for `strDDDMMSS` are parsed properly only if either unsigned and suffixed with a valid, compatible, `cardinal` compassPoint or if unsigned or signed, unsuffixed and with keyword argument `suffix` set to 'NS', 'EW' or a compatible compassPoint. Unlike function parseDMS, type `float`, `int` and other non-`str` `strDDDMMSS` values are interpreted form [D]DDMMSS. 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 compass point 'NS'. See Also: Functions parseDMS, parseDMS2 and parse3llh.

### parseDMS (strDMS, suffix=`'``NSEW``'`, sep=`'````'`, clip=0) |
Parse a lat- or longitude represention 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 -clip..+clip (`degrees`). Returns: Degrees (`float`). Raises: `ParseError` - Invalid `strDMS` or `clip`. `RangeError` - Value of `strDMS` outside the valid range and rangerrors set to `True`. Note: Inlike function parseDDDMMSS, type `float`, `int` and other non-`str` `strDMS` values are considered as decimal 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 parseDDDMMSS, parseDMS2 and parse3llh.

### parseDMS2 (strLat, strLon, sep=`'````'`, clipLat=90, clipLon=180) |
Parse lat- and longitude representions 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` - Keep latitude in `-clipLat..+clipLat` range (`degrees`). `clipLon` - Keep longitude in `-clipLon..+clipLon` range (`degrees`). Returns: A LatLon2Tuple`(lat, lon)` in `degrees`. Raises: `ParseError` - Invalid `strLat` or `strLon`. `RangeError` - Value of `strLat` or `strLon` outside the valid range and rangerrors set to `True`. Note: See the Notes at function parseDMS. See Also: Functions parseDDDMMSS, parseDMS and parse3llh.

### 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 `datum`. Example:
    >>> u = parseETM5('31 N 448251 5411932')
    >>> u.toStr2()  # [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 and 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 (Mgrs) or an Mgrs4Tuple`(zone, digraph, easting, northing)` if `Mgrs` is `None`. Raises: `MGRSError` - Invalid `strMGRS`. 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 an OSGR coordinate string to an Osgr instance. 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 fully 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: `OSGRError` - Invalid `strOSGR`. 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 -clip..+clip (`radians`). Returns: Radians (`float`). Raises: `ParseError` - Invalid `strRad` or `clip`. `RangeError` - Value of `strRad` outside the valid range and rangerrors set to `True`.

### 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: `UPSError` - Invalid `strUPS`.

### parseUTM (strUTM, datum=_R_M, Utm=_R_M, name=`'````'`) |
DEPRECATED, use function parseUTM5. Returns: The UTM coordinate (Utm) or 4-tuple `(zone, hemisphere, easting, northing)` if `Utm` is `None`.

### 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.toStr2()  # [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: `UTMUPSError` - Invalid `strUTMUPS`. See Also: Functions parseUTM5 and parseUPS5.

### parseWM (strWM, radius=6378137.0, Wm=<class 'pygeodesy.webmercator.Wm'>, name=`'````'`) |
Parse a string 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: `WebMercatorError` - Invalid `strWM`. Example:
    >>> u = parseWM('448251 5411932')
    >>> u.toStr2()  # [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 equirectangular_ distance approximation and is ill-suited for regions exceeding several hundred Km or Miles or with near-polar latitudes. See Also: sphericalTrigonometry.perimeterOf and ellipsoidalKarney.perimeterOf.

### philam2n_xyz (phi, lam) |
Convert lat-, longitude to `n-vector` (normal to the earth's surface) X, Y and Z components. Arguments: `phi` - Latitude (`radians`). `lam` - Longitude (`radians`). 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!

### 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.

### precision (form, prec=None) |
Set the default precison for a given F_ form. Arguments: `form` - F_D, F_DM, F_DMS, F_DEG, F_MIN, F_SEC, F__E, F__F, F__G or F_RAD (`str`). `prec` - Optional 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`. Returns: Previous precision (`int`). Raises: `ValueError` - Invalid `form` or `prec` or `prec` outside valid range.

### property_doc_ (doc) |
Decorator for a property with documentation. Arguments: `doc` - The property documentation (`str`). Example:
    >>> @property_doc_("documentation text.")
    >>> def name(self):
    >>>     ...
    >>>
    >>> @name.setter
    >>> def name(self, value):
    >>>     ...

### quadOf (lat1, lon1, lat2, lon2, closed=False, LatLon=<class 'pygeodesy.points.LatLon_'>, **LatLon_kwds) |
Generate a quadrilateral path or polygon from two points. Arguments: `lat1` - Lower latitude (`degrees90`). `lon1` - Left longitude (`degrees180`). `lat2` - Upper latitude (`degrees90`). `lon2` - Right longitude (`degrees180`). `closed` - Optionally, close the path (`bool`). `LatLon` - Class to use (LatLon_). `LatLon_kwds` - Optional, additional `LatLon` keyword arguments. Returns: Yield 4 or 5 `LatLon` instances outlining the quadrilateral.

### 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: `IntersectionError` - The `distance` exceeds the sum of `radius1` and `radius2`. `UnitError` - Invalid `distance`, `radius1` or `radius2`.

### randomrangenerator (seed) |
Return a `seed`ed random range function generator. Arguments: `seed` - Initial, internal Random state (`hashable` or `None`). Returns: A function to generate random ranges. Note: Random `seed=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 `float`s handled like fstr. Arguments: `objs` - List, sequence, tuple, etc. (any `type`s). `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 (`bool`). Returns: A `tuple(map(fstr|repr, objs))` of `str`s.

### scalar (value, low=2.22044604925e-16, high=1.0, name=`'``scalar``'`, Error=<type 'exceptions.ValueError'>) |
DEPRECATED, use class Number_ or Scalar_. Arguments: `value` - The value (`scalar`). `low` - Optional lower bound (`scalar`). `high` - Optional upper bound (`scalar`). `name` - Optional name of value (`str`). `Error` - Exception to raise (`ValueError`). Returns: New value (`float` or `int` for `int` `low`). Raises: `Error` - Invalid `value`.

### simplify1 (points, distance, 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 equirectangular_. Returns: Simplified points (`LatLon`[]). Raises: `LimitError` - Lat- and/or longitudinal delta exceeds the `limit`, see function equirectangular_. `ValueError` - Tolerance `distance` or `radius` too small.

### simplifyRDP (points, distance, 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 equirectangular_. Returns: Simplified points (`LatLon`[]). Raises: `LimitError` - Lat- and/or longitudinal delta exceeds the `limit`, see function equirectangular_. `ValueError` - Tolerance `distance` or `radius` too small.

### simplifyRDPm (points, distance, 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 equirectangular_. Returns: Simplified points (`LatLon`[]). Raises: `LimitError` - Lat- and/or longitudinal delta exceeds the `limit`, see function equirectangular_. `ValueError` - Tolerance `distance` or `radius` too small.

### simplifyRW (points, pipe, 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` - Half pipe 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 equirectangular_. Returns: Simplified points (`LatLon`[]). Raises: `LimitError` - Lat- and/or longitudinal delta exceeds the `limit`, see function equirectangular_. `ValueError` - Tolerance `pipe` or `radius` too small.

### simplifyVW (points, area, 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 save area value (`str`). `indices` - Optionally return the simplified point indices instead of the simplified points (`bool`). `options` - Optional keyword arguments passed thru to function 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 equirectangular_. `ValueError` - Tolerance `area` or `radius` too small.

### simplifyVWm (points, area, 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 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 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 equirectangular_. `ValueError` - Tolerance `area` or `radius` too small.

### sincos2 (*rad) |
Return the `sine` and `cosine` of angle(s). Arguments: `rad` - One or more angles (`radians`). Returns: The `sin(rad)` and `cos(rad)` for each angle. See Also: GeographicLib function sincosd and C++ sincosd.

### sincos2d (*deg) |
Return the `sine` and `cosine` of angle(s) in `degrees`. Arguments: `deg` - One or more angles (`degrees`). Returns: The `sin(rad)` and `cos(rad)` for each angle. See Also: GeographicLib function sincosd and C++ sincosd.

### 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: `ValueError` - 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...>

### sqrt3 (x) |
Compute the square root, cubed sqrt(x)**3 or sqrt(x**3). Arguments: `x` - Value (`scalar`). Returns: Cubed square root (`float`). Raises: `ValueError` - Negative `x`. See Also: Functions cbrt and cbrt2.

### strs (objs, prec=6, fmt=`'``F``'`, ints=False) |
Convert objects to `str` strings, with `float`s handled like fstr. Arguments: `objs` - List, sequence, tuple, etc. (any `type`s). `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 (`bool`). Returns: A `tuple(map(fstr|str, objs))` of `str`s.

### 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) |
Compute the tangent of half angle. Arguments: `rad` - Angle (`radians`). Returns: tan(rad / 2) (`float`).

### 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` - Ellipsoidal datum to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple). `wrap` - Wrap and unroll180 longitudes (`bool`). Returns: Distance (`meter`, same units as the `datum`'s ellipsoid axes). Raises: `TypeError` - Invalid `datum`. See Also: Functions thomas_, cosineAndoyerLambert, cosineForsytheAndoyerLambert, cosineLaw, equirectangular, euclidean, flatLocal/hubeny, flatPolar, haversine, vincentys and method Ellipsoid.distance2.

### 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` - Ellipsoidal datum to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple). Returns: Angular distance (`radians`). Raises: `TypeError` - Invalid `datum`. See Also: Functions thomas, cosineAndoyerLambert_, cosineForsytheAndoyerLambert_, cosineLaw_, equirectangular_, euclidean_, flatLocal_/hubeny_, flatPolar_, haversine_ and vincentys_ and Geodesy-PHP.

### 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 missing. `TypeError` - If `latlon` is not ellipsoidal.

### toDMS (deg, form=`'``dms``'`, prec=2, sep=`'````'`, ddd=2, neg=`'``-``'`, pos=`'````'`) |
Convert signed degrees to string, without suffix. Arguments: `deg` - Degrees to be formatted (`degrees`). `form` - Optional `deg` format (`str` or F_D, F_DM, F_DMS, F_DEG, F_MIN, F_SEC, F__E, F__F, F__G, F_RAD, F_D_, F_DM_, F_DMS_, F_DEG_, F_MIN_, F_SEC_, F__E_, F__F_, F__G_, F_RAD_, F_D__, F_DM__, F_DMS__, F_DEG__, F_MIN__, F_SEC__, F__E__, F__F__, F__G__ or F_RAD__). `prec` - Optional 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`. `sep` - Optional separator (`str`). `ddd` - Optional number of digits for deg° (2 or 3). `neg` - Optional sign for negative degrees ('-'). `pos` - Optional sign for positive degrees (''). Returns: Degrees in the specified form (`str`).

### 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. `ETMError` - Invalid `zone`. `RangeError` - If `lat` outside the valid UTM bands or if `lat` or `lon` outside the valid range and rangerrors set to `True`. `TypeError` - Invalid `datum` or `latlon` not ellipsoidal. `ValueError` - If `lon` value is missing or if `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=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=None`. Returns: The MGRS grid reference (Mgrs) or an Mgrs6Tuple`(zone, digraph, easting, northing, band, datum)` if Mgrs is `None`. Raises: `TypeError` - If `utm` is not Utm nor Etm. `MGRSError` - Invalid `utm`. 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=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` 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 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=_R_M, cmoff=True, name=`'````'`) |
DEPRECATED, use function toUtm8. Returns: The UTM coordinate (`Utm`) or a 6-tuple `(zone, easting, northing, band, convergence, scale)` if `Utm` is `None` or `cmoff` is `False`.

### 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 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 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 toUtm8 and 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=None`. Returns: The WM coordinate (`Wm`) or an EasNorRadius3Tuple`(easting, northing, radius)` if `Wm` is `None`. Raises: `ValueError` - If `lon` value is missing, if `latlon` is not scalar, if `latlon` is beyond the valid WM range and 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

### 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.

### unstr (name, *args, **kwds) |
Return the string representation of an invokation. Arguments: `name` - Function, method or class name (`str`). `args` - Optional positional arguments. `kwds` - Optional keyword arguments. Returns: Representation (`str`).

### upsZoneBand5 (lat, lon, strict=True) |
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`). 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 rangerrors set to `True`. `ValueError` - Invalid `lat` or `lon`.

### utmZoneBand2 (lat, lon) |
DEPRECATED, use function utmZoneBand5. Returns: 2-Tuple `(zone, band)`.

### utmZoneBand5 (lat, lon, cmoff=False) |
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`). 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 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) |
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`). 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 rangerrors set to `True`. `ValueError` - Invalid `lat` or `lon`. See Also: Functions utmZoneBand5 and upsZoneBand5.

### 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 (`meter`). `wrap` - Wrap and unroll180 longitudes (`bool`). Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - Invalid `radius`. 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).

### 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`).

Variables Details

  ### pygeodesy_abspath Fully qualified `pygeodesy` directory name (`str`). Value:
      '..../PyGeodesy/pygeodesy'

  ### Conics Registered conics (`enum-like`). Value:
      Conics.Be08Lb: Conic(name='Be08Lb', lat0=50.797815, lon0=4.35921583, p
      ar1=49.833333, par2=51.166667, E0=649328, N0=665262, k0=1, SP=2, datum
      =Datum(name='GRS80', ellipsoid=Ellipsoids.GRS80, transform=Transforms.
      WGS84),
      Conics.Be72Lb: Conic(name='Be72Lb', lat0=90, lon0=4.3674867, par1=49.8
      333339, par2=51.1666672, E0=150000.013, N0=5400088.438, k0=1, SP=2, da
      tum=Datum(name='NAD83', ellipsoid=Ellipsoids.GRS80, transform=Transfor
      ms.NAD83),
      ...

  ### Datums Registered datums (`enum-like`). Value:
      Datums.BD72: Datum(name='BD72', ellipsoid=Ellipsoids.Intl1924, transfo
      rm=Transforms.BD72),
      Datums.DHDN: Datum(name='DHDN', ellipsoid=Ellipsoids.Bessel1841, trans
      form=Transforms.DHDN),
      Datums.ED50: Datum(name='ED50', ellipsoid=Ellipsoids.Intl1924, transfo
      rm=Transforms.ED50),
      Datums.GDA2020: Datum(name='GDA2020', ellipsoid=Ellipsoids.GRS80, tran
      sform=Transforms.WGS84),
      ...

  ### Ellipsoids Registered 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, L=10001
      126.0807165, R1=6370461.23374576, R2=6370459.65470808, R3=6370453.3099
      4572),
      Ellipsoids.AiryModified: Ellipsoid(name='AiryModified', a=6377340.189,
       b=6356034.44793853, f_=299.3249646, f=0.00334085, f2=0.00335205, n=0.
      00167322, e=0.08167337, e2=0.00667054, e22=0.00671533, e32=0.00334643,
      ...

  ### RefFrames Registered reference frames (`enum-like`). Value:
      RefFrames.ETRF2000: RefFrame(name='ETRF2000', epoch=2005.0, ellipsoid=
      Ellipsoid(name='GRS80'),
      RefFrames.GDA94: RefFrame(name='GDA94', epoch=1994.0, ellipsoid=Ellips
      oid(name='GRS80'),
      RefFrames.ITRF2000: RefFrame(name='ITRF2000', epoch=1997.0, ellipsoid=
      Ellipsoid(name='GRS80'),
      RefFrames.ITRF2005: RefFrame(name='ITRF2005', epoch=2000.0, ellipsoid=
      Ellipsoid(name='GRS80'),
      ...

  ### Transforms Registered transforms (`enum-like`). Value:
      Transforms.BD72: Transform(name='BD72', tx=106.86863, ty=-52.29778, tz
      =103.72389, rx=-0, ry=-0, rz=-0.00001, s=1.2727, s1=1, sx=-0.33657, sy
      =-0.45696, sz=-1.84218),
      Transforms.Bessel1841: Transform(name='Bessel1841', tx=-582, ty=-105,
      tz=-414, rx=-0.00001, ry=-0, rz=0.00001, s=-8.3, s1=0.99999, sx=-1.04,
       sy=-0.35, sz=3.08),
      Transforms.Clarke1866: Transform(name='Clarke1866', tx=8, ty=-160, tz=
      -176, rx=0, ry=0, rz=0, s=0, s1=1, sx=0, sy=0, sz=0),
      ...