A pure Python implementation of geodesy tools for various ellipsoidal
and spherical earth models using precision trigonometric, vector-based,
exact, elliptic and approximate methods for geodetic (lat-/longitude) and
geocentric (ECEF cartesian) coordinates.
Previously, the tests were run with Python 3.9.0-5, 3.8.0-6,
3.7.2-6, 3.7.0, 3.6.2-5, 3.5.3, 2.7.13-17, 2.7.10 and 2.6.9 (and numpy 1.19.0,
1.16.5, 1.16.2, 1.15.2, 1.14.0, 1.13.1, 1.8.0rc1 or 1.6.2 and scipy 1.5.0),
PyPy 7.3.0 (Python 2.7.13
and 3.6.9), PyPy 6.0.0
(Python 2.7.13 and 3.5.3) and Intel-Python 3.5.3 (and numpy 1.11.3)
on macOS 11.0-5.2-6.1 Big Sur (aka 10.16), 10.15.3, 10.15.5-7 Catalina,
macOS 10.14 Mojave, macOS 10.13.6 High Sierra, macOS 10.12 Sierra,
MacOS X 10.11 El Capitan and/or MacOS X 10.10 Yosemite, with Pythonista3.2 (with geographiclib 1.50 or 1.49 and
numpy 1.8.0) on iOS 14.4.2, 11.4.1, 12.0-3 on iPad4, iPhone6 and/or
iPhone10, with Pythonista 3.1 on iOS 10.3.3, 11.0.3, 11.1.2 and 11.3
on iPad4, all in 64-bit only and with 32-bit Python 2.7.14 on Windows
10 Pro and with 32-bit Python 2.6.6 on Windows XP SP3.
Some function and method names differ from the JavaScript version.
In such cases documentation tag JS name: shows the original
JavaScript name.
|
LazyImportError
Raised if lazy import is not supported, disabled or
failed some other way.
|
|
Ned3Tuple
3-Tuple (north, east, down) .
|
|
VincentyError
Error raised from Vincenty's direct and
inverse methods for coincident points or lack of
convergence.
|
|
Epsg
EPSG
class, a named int .
|
|
EPSGError
EPSG encode, decode or other Epsg issue.
|
|
Garef
Garef class, a named str .
|
|
GARSError
Global Area Reference System (GARS) encode, decode or other Garef
issue.
|
|
Geohash
Geohash class, a named str .
|
|
GeohashError
Geohash encode, decode or other Geohash issue.
|
|
Neighbors8Dict
8-Dict (N, NE, E, SE, S, SW, W, NW) of Geohashes, providing key and attribute
access to the items.
|
|
Resolutions2Tuple
2-Tuple (res1, res2) with the primary
(longitudinal) and secondary (latitudinal)
resolution, both in degrees .
|
|
Georef
Georef class, a named str .
|
|
WGRSError
World Geographic Reference System (WGRS) encode, decode or other Georef
issue.
|
|
Aer
Local Azimuth-Elevation-Range (AER) in a local
tangent plane.
|
|
Aer4Tuple
4-Tuple (azimuth, elevation, slantrange, ltp) , all in
meter except ltp .
|
|
Albers7Tuple
7-Tuple (x, y, lat, lon, gamma, scale, datum) , in
meter , meter , degrees90 ,
degrees180 , degrees360 ,
scalar and Datum where (x,
y) is the projected, (lat, lon) the geodetic
location, gamma the meridian convergence at point, the
bearing of the y-axis measured clockwise from true North and
scale is the azimuthal scale of the projection at
point.
|
|
AlbersEqualArea
An Albers equal-area (authalic) projection with a single standard
parallel.
|
|
AlbersEqualArea2
An Albers equal-area (authalic) projection with two standard
parallels.
|
|
AlbersEqualArea4
An Albers equal-area (authalic) projection specified by the
sin and cos of both standard parallels.
|
|
AlbersEqualAreaCylindrical
An AlbersEqualArea projection at lat=0
and k0=1 degenerating to the cylindrical-equal-area
projection.
|
|
AlbersEqualAreaNorth
An azimuthal AlbersEqualArea projection at lat=90
and k0=1 degenerating to the azimuthal
LambertEqualArea projection.
|
|
AlbersEqualAreaSouth
An azimuthal AlbersEqualArea projection at lat=-90
and k0=1 degenerating to the azimuthal
LambertEqualArea projection.
|
|
AlbersError
An AlbersEqualArea, AlbersEqualArea2, AlbersEqualArea4, AlbersEqualAreaCylindrical, AlbersEqualAreaNorth, AlbersEqualAreaSouth or Albers7Tuple issue.
|
|
Attitude
The orientation of a plane or camera in space.
|
|
Attitude4Tuple
4-Tuple (alt, tilt, yaw, roll) with
altitude in (positive) meter and
tilt , yaw and roll in
degrees representing the attitude of a plane or
camera.
|
|
AttitudeError
An Attitude or Attitude4Tuple issue.
|
|
Azimuthal7Tuple
7-Tuple (x, y, lat, lon, azimuth, scale, datum) , in
meter , meter , degrees90 ,
degrees180 , compass degrees ,
scalar and Datum where (x,
y) is the easting and northing of a projected point,
(lat, lon) the geodetic location, azimuth
the azimuth, clockwise from true North and scale is
the projection scale, either 1 / reciprocal or
1 or -1 in the Equidistant case.
|
|
AzimuthalError
An azimuthal Equidistant, EquidistantKarney, Gnomonic, LambertEqualArea, Orthographic, Stereographic or Azimuthal7Tuple issue.
|
|
Band
Named str representing a UTM/UPS band letter,
unchecked.
|
|
Bearing
Named float representing a bearing in compass
degrees from (true) North.
|
|
Bearing2Tuple
2-Tuple (initial, final) bearings, both in compass
degrees360 .
|
|
Bearing_
Named float representing a bearing in
radians from compass degrees from (true)
North.
|
|
Bool
Named bool , a sub-class of int like
Python's bool .
|
|
Bounds2Tuple
2-Tuple (latlonSW, latlonNE) with the bounds'
lower-left and upper-right corner as LatLon instance.
|
|
Bounds4Tuple
4-Tuple (latS, lonW, latN, lonE) with the bounds'
lower-left (LatS, LowW) and upper-right (latN,
lonE) corner lat- and longitudes.
|
|
CSSError
Cassini-Soldner (CSS) conversion or other Css issue.
|
|
CassiniSoldner
Cassini-Soldner projection, a Python version of Karney's C++
class CassiniSoldner.
|
|
Circin6Tuple
6-Tuple (radius, center, deltas, cA, cB, cC) with the
radius , the trilaterated center and
contact points of the inscribed aka In- circle of a
triangle.
|
|
Circle4Tuple
4-Tuple (radius, height, lat, beta) of the
radius and height , both conventionally in
meter of a parallel circle of latitude at
(geodetic) latitude lat and the parametric (or
reduced) auxiliary latitude beta , both in
degrees90 .
|
|
Circum3Tuple
3-Tuple (radius, center, deltas) with the
circumradius and trilaterated
circumcenter of the circumcircle through
3 points (aka {Meeus}' Type II circle) or the radius
and center of the smallest Meeus' Type I
circle.
|
|
Circum4Tuple
4-Tuple (radius, center, rank, residuals) with
radius and center of a sphere
least-squares fitted through given points and the
rank and residuals -if any- from numpy.linalg.lstsq.
|
|
ClipCS3Tuple
3-Tuple (start, end, index) .
|
|
ClipCS4Tuple
4-Tuple (start, end, i, j) for each edge of a
clipped path with the start and
end points (LatLon ) of the portion of the
edge inside or on the clip box and the indices i and
j (int ) of the edge start and end points
in the original path.
|
|
ClipError
Clip box or clip region issue.
|
|
ClipLB6Tuple
6-Tuple (start, end, i, fi, fj, j) for each edge of
the clipped path with the start and
end points (LatLon ) of the portion of the
edge inside or on the clip box, indices i and
j (both int ) of the original path edge
start and end points and fractional indices fi
and fj (both FIx) of the start and
end points along the edge of the original path.
|
|
ClipSH3Tuple
3-Tuple (start, end, original) for each edge of a
clipped polygon, the start and end
points (LatLon ) of the portion of the edge inside or
on the clip region and original indicates whether the
edge is part of the original polygon or part of the clip region
(bool ).
|
|
Collins5Tuple
5-Tuple (pointP, pointH, a, b, c) with survey
pointP , auxiliary pointH , each an
instance of pointA 's (sub-)class and triangle
sides a , b and c in
meter , conventionally.
|
|
Conic
Lambert conformal conic projection (1- or 2-SP).
|
|
CrossError
Error raised for zero or near-zero vectorial cross products,
occurring for coincident or colinear points, paths or bearings.
|
|
Css
Cassini-Soldner East-/Northing location.
|
|
Curvature2Tuple
2-Tuple (meridional, prime_vertical) of radii of
curvature, both in meter , conventionally.
|
|
Datum
Ellipsoid and transform parameters for an earth model.
|
|
Degrees
Named float representing a coordinate in
degrees , optionally clipped.
|
|
Degrees2
Named float representing a distance in degrees
squared .
|
|
Degrees_
Named Degrees representing a coordinate in
degrees with optional limits low and
high .
|
|
Destination2Tuple
2-Tuple (destination, final) , destination
in LatLon and final bearing in compass
degrees360 .
|
|
Destination3Tuple
3-Tuple (lat, lon, final) , destination
lat , lon in degrees90
respectively degrees180 and final bearing
in compass degrees360 .
|
|
Direct9Tuple
9-Tuple (a12, lat2, lon2, azi2, s12, m12, M12, M21,
S12) with arc length a12 , angles
lat2 , lon2 and azimuth azi2
in degrees , distance s12 and reduced
length m12 in meter and area
S12 in meter squared.
|
|
Distance
Named float representing a distance, conventionally in
meter .
|
|
Distance2Tuple
2-Tuple (distance, initial) , distance in
meter and initial bearing in compass
degrees360 .
|
|
Distance3Tuple
3-Tuple (distance, initial, final) ,
distance in meter and
initial and final bearing, both in
compass degrees360 .
|
|
Distance4Tuple
4-Tuple (distance2, delta_lat, delta_lon, unroll_lon2)
with the distance in degrees squared , the latitudinal
delta_lat = lat2 - lat1 , the wrapped,
unrolled and adjusted longitudinal delta_lon = lon2 -
lon1 and unroll_lon2 , the unrolled or
original lon2 .
|
|
Distance_
Named float with optional low and
high limits representing a distance, conventionally in
meter .
|
|
ETMError
Exact Transverse Mercator (ETM) parse, projection or other Etm issue.
|
|
EasNor2Tuple
2-Tuple (easting, northing) , both in
meter , conventionally.
|
|
EasNor3Tuple
3-Tuple (easting, northing, height) , all in
meter , conventionally.
|
|
EasNorAziRk4Tuple
4-Tuple (easting, northing, azimuth, reciprocal) for
the Cassini-Soldner location with easting and
northing in meters and the
azimuth of easting direction and
reciprocal of azimuthal northing scale, both in
degrees .
|
|
EasNorExact4Tuple
4-Tuple (easting, northing, convergence, scale) in
meter , meter , degrees and
scalar .
|
|
EasNorRadius3Tuple
3-Tuple (easting, northing, radius) , all in
meter .
|
|
Easting
Named float representing an easting, conventionally in
meter .
|
|
Ecef9Tuple
9-Tuple (x, y, z, lat, lon, height, C, M, datum) with
geocentric x , y and z
plus geodetic lat , lon and
height , case C (see the
Ecef*.reverse methods) and optionally, the rotation
matrix M (EcefMatrix) and datum , with
lat and lon in degrees and
x , y , z and
height in meter , conventionally.
|
|
EcefCartesian
DEPRECATED, use class LocalCartesian.
|
|
EcefError
An ECEF or Ecef* related issue.
|
|
EcefFarrell21
Conversion between geodetic and geocentric, aka Earth-Centered,
Earth-Fixed (ECEF) coordinates based on Jay A. Farrell's
Table 2.1, page 29.
|
|
EcefFarrell22
Conversion between geodetic and geocentric, aka Earth-Centered,
Earth-Fixed (ECEF) coordinates based on Jay A. Farrell's
Table 2.2, page 30.
|
|
EcefKarney
Conversion between geodetic and geocentric, aka Earth-Centered,
Earth-Fixed (ECEF) coordinates transcoded from Karney's
C++ Geocentric methods.
|
|
EcefMatrix
A rotation matrix.
|
|
EcefSudano
Conversion between geodetic and geocentric, aka Earth-Centered,
Earth-Fixed (ECEF) coordinates based on John J. Sudano's
paper.
|
|
EcefVeness
Conversion between geodetic and geocentric, aka Earth-Centered,
Earth-Fixed (ECEF) coordinates transcoded from Chris
Veness' JavaScript classes LatLonEllipsoidal, Cartesian.
|
|
EcefYou
Conversion between geodetic and geocentric, aka Earth-Centered,
Earth-Fixed (ECEF) coordinates using Rey-Jer You's transformation.
|
|
Elevation2Tuple
2-Tuple (elevation, data_source) in meter
and str .
|
|
Ellipsoid
Ellipsoid with equatorial and polar radii,
flattening, inverse flattening and other, often used,
cached attributes, supporting oblate and
prolate ellipsoidal and spherical earth models.
|
|
Ellipsoid2
An Ellipsoid specified by equatorial radius
and flattening.
|
|
Elliptic
Elliptic integrals and functions.
|
|
Elliptic3Tuple
3-Tuple (sn, cn, dn) all scalar .
|
|
EllipticError
Elliptic integral, function, convergence or other Elliptic issue.
|
|
Enu
Local Eeast-North-Up (ENU) location in a local
tangent plane.
|
|
Enu4Tuple
4-Tuple (east, north, up, ltp) , in meter
except ltp .
|
|
Epoch
Named epoch with optional low and
high limits representing a fractional calendar year.
|
|
Equidistant
Azimuthal equidistant projection for the sphere**, see Snyder, pp 195-197 and MathWorld-Wolfram.
|
|
EquidistantExact
Azimuthal equidistant projection, a Python version of
Karney's C++ class AzimuthalEquidistant, based on exact geodesic
classes GeodesicExact and GeodesicLineExact.
|
|
EquidistantGeodSolve
Azimuthal equidistant projection, a Python version of
Karney's C++ class AzimuthalEquidistant, based on (exact) geodesic
wrappers GeodesicSolve and GeodesicLineSolve and intended for testing
purposes only.
|
|
EquidistantKarney
Azimuthal equidistant projection, a Python version of
Karney's C++ class AzimuthalEquidistant, requiring package geographiclib to be installed.
|
|
Etm
Exact Transverse Mercator (ETM) coordinate, a sub-class of Utm, a
Universal Transverse Mercator (UTM) coordinate using the ExactTransverseMercator projection for highest
accuracy.
|
|
ExactTransverseMercator
A Python version of Karney's TransverseMercatorExact C++ class, a numerically
exact transverse mercator projection, here referred to as
TMExact .
|
|
FIx
A named Fractional Index, an int or
float index into a list or
tuple of points , typically.
|
|
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.
|
|
Footprint5Tuple
5-Tuple (center, upperleft, upperight, loweright,
lowerleft) with the center and 4 corners of a
local projection of a Frustum , each an Xyz4Tuple.
|
|
Fpolynomial
Precision polynomial evaluation.
|
|
Frechet
Frechet base class, requires method Frechet.distance to be overloaded.
|
|
Frechet6Tuple
6-Tuple (fd, fi1, fi2, r, n, units) with the
discrete Fréchet distance fd ,
fractional indices fi1 and fi2 as
FIx , the recursion depth r , the number of
distances computed n and the units class or class or name of the distance
units .
|
|
FrechetCosineAndoyerLambert
Compute the Frechet distance based on the
angular distance in radians from function pygeodesy.cosineAndoyerLambert_.
|
|
FrechetCosineForsytheAndoyerLambert
Compute the Frechet distance based on the
angular distance in radians from function pygeodesy.cosineForsytheAndoyerLambert_.
|
|
FrechetCosineLaw
Compute the Frechet distance based on the
angular distance in radians from function pygeodesy.cosineLaw_.
|
|
FrechetDegrees
Frechet base class for distances in
degrees from LatLon points in
degrees .
|
|
FrechetDistanceTo
Compute the Frechet distance based on the distance
from the points' LatLon.distanceTo method,
conventionally in meter .
|
|
FrechetEquirectangular
Compute the Frechet distance based on the
equirectangular distance in radians squared
like function pygeodesy.equirectangular_.
|
|
FrechetError
Fréchet issue.
|
|
FrechetEuclidean
Compute the Frechet distance based on the
Euclidean distance in radians from function pygeodesy.euclidean_.
|
|
FrechetExact
Compute the Frechet distance based on the
angular distance in degrees from method GeodesicExact.Inverse .
|
|
FrechetFlatLocal
Compute the Frechet distance based on the
angular distance in radians squared like
function pygeodesy.flatLocal_/pygeodesy.hubeny_.
|
|
FrechetFlatPolar
Compute the Frechet distance based on the
angular distance in radians from function flatPolar_.
|
|
FrechetHaversine
Compute the Frechet distance based on the
angular distance in radians from function pygeodesy.haversine_.
|
|
FrechetHubeny
Compute the Frechet distance based on the
angular distance in radians squared like
function pygeodesy.flatLocal_/pygeodesy.hubeny_.
|
|
FrechetKarney
Compute the Frechet distance based on the
angular distance in degrees from
Karney's geographiclib Geodesic Inverse method.
|
|
FrechetRadians
Frechet base class for distances in
radians or radians squared from
LatLon points converted from degrees to
radians .
|
|
FrechetThomas
Compute the Frechet distance based on the
angular distance in radians from function pygeodesy.thomas_.
|
|
FrechetVincentys
Compute the Frechet distance based on the
angular distance in radians from function pygeodesy.vincentys_.
|
|
Frustum
A rectangular pyramid, typically representing a camera's
field-of-view (fov) and the intersection with (or projection
to) a local tangent plane.
|
|
Fsum
Precision summation similar to standard Python function
math.fsum .
|
|
GDict
Basic dict with both key and attribute access
to the dict items.
|
|
GeodSolve12Tuple
12-Tuple (lat1, lon1, azi1, lat2, lon2, azi2, s12, a12, m12,
M12, M21, S12) with angles lat1 ,
lon1 , azi1 , lat2 ,
lon2 and azi2 and arc a12
all in degrees , distance s12 and reduced
length m12 in meter , area
S12 in meter squared and geodesic
scales M12 and M21 scalar ,
see GeodSolve.
|
|
GeodesicAreaExact
Area and perimeter of a geodesic polygon, an enhanced version of
Karney's Python class PolygonArea using the more accurate surface area.
|
|
GeodesicError
Error raised for geodesicx's methods for lack of convergence
or other issues.
|
|
GeodesicExact
A pure Python version of Karney's C++ class GeodesicExact, modeled after Karney's
Python class Geodesic.
|
|
GeodesicLineExact
A pure Python version of Karney's C++ class GeodesicLineExact, modeled after Karney's
Python class GeodesicLine.
|
|
GeodesicLineSolve
Wrapper to invoke Karney's GeodSolve as an Exact version of
Karney's Python class GeodesicLine.
|
|
GeodesicSolve
Wrapper to invoke Karney's GeodSolve as an Exact version of
Karney's Python class Geodesic.
|
|
GeoidError
Geoid interpolator Geoid... or interpolation issue.
|
|
GeoidG2012B
Geoid height interpolator for GEOID12B Model grids CONUS, Alaska, Hawaii, Guam and Northern Mariana Islands, Puerto Rico and U.S. Virgin Islands and American Samoa based on SciPy RectBivariateSpline or interp2d interpolation.
|
|
GeoidHeight2Tuple
2-Tuple (height, model_name) , geoid
height in meter and
model_name as str .
|
|
GeoidHeight5Tuple
5-Tuple (lat, lon, egm84, egm96, egm2008) for GeoidHeights.dat tests with the heights for 3
different EGM grids at degrees90 and
degrees180 degrees (after converting lon
from original 0 <= EasterLon <= 360 ).
|
|
GeoidKarney
Geoid height interpolator for Karney's GeographicLib Earth Gravitational Model (EGM)
geoid egm*.pgm datasets using bilinear or cubic interpolation and caching in pure Python, transcoded from
Karney's C++ class Geoid.
|
|
GeoidPGM
Geoid height interpolator for Karney's GeographicLib Earth Gravitational Model (EGM)
geoid egm*.pgm datasets but based on SciPy
RectBivariateSpline or interp2d interpolation.
|
|
Gnomonic
Azimuthal gnomonic projection for the sphere**, see Snyder, pp 164-168 and MathWorld-Wolfram.
|
|
GnomonicExact
Azimuthal gnomonic projection, a Python version of Karney's
C++ class Gnomonic, based on exact geodesic classes GeodesicExact and GeodesicLineExact.
|
|
GnomonicGeodSolve
Azimuthal gnomonic projection, a Python version of Karney's
C++ class Gnomonic, based on (exact) geodesic
wrappers GeodesicSolve and GeodesicLineSolve and intended for testing
purposes only.
|
|
GnomonicKarney
Azimuthal gnomonic projection, a Python version of Karney's
C++ class Gnomonic, requiring package geographiclib to be installed.
|
|
Hausdorff
Hausdorff base class, requires method Hausdorff.distance to be overloaded.
|
|
Hausdorff6Tuple
6-Tuple (hd, i, j, mn, md, units) with the Hausdorff distance hd , indices
i and j , the total count mn ,
the mean Hausdorff distance md and
the class or name of both distance units .
|
|
HausdorffCosineAndoyerLambert
Compute the Hausdorff distance based on the
angular distance in radians from function pygeodesy.cosineAndoyerLambert_.
|
|
HausdorffCosineForsytheAndoyerLambert
Compute the Hausdorff distance based on the
angular distance in radians from function pygeodesy.cosineForsytheAndoyerLambert_.
|
|
HausdorffCosineLaw
Compute the Hausdorff distance based on the
angular distance in radians from function pygeodesy.cosineLaw_.
|
|
HausdorffDegrees
Hausdorff base class for distances from
LatLon points in degrees .
|
|
HausdorffDistanceTo
Compute the Hausdorff distance based on the distance
from the points' LatLon.distanceTo method,
conventionally in meter .
|
|
HausdorffEquirectangular
Compute the Hausdorff distance based on the
equirectangular distance in radians
squared like function pygeodesy.equirectangular_.
|
|
HausdorffError
Hausdorff issue.
|
|
HausdorffEuclidean
Compute the Hausdorff distance based on the
Euclidean distance in radians from
function pygeodesy.euclidean_.
|
|
HausdorffExact
Compute the Hausdorff distance based on the
angular distance in degrees from method GeodesicExact.Inverse .
|
|
HausdorffFlatLocal
Compute the Hausdorff distance based on the
angular distance in radians squared like
function pygeodesy.flatLocal_/pygeodesy.hubeny_.
|
|
HausdorffFlatPolar
Compute the Hausdorff distance based on the
angular distance in radians from function pygeodesy.flatPolar_.
|
|
HausdorffHaversine
Compute the Hausdorff distance based on the
angular distance in radians from function pygeodesy.haversine_.
|
|
HausdorffHubeny
Compute the Hausdorff distance based on the
angular distance in radians squared like
function pygeodesy.flatLocal_/pygeodesy.hubeny_.
|
|
HausdorffKarney
Compute the Hausdorff distance based on the
angular distance in degrees from
Karney's geographiclib Geodesic Inverse method.
|
|
HausdorffRadians
Hausdorff base class for distances from
LatLon points converted from degrees to
radians .
|
|
HausdorffThomas
Compute the Hausdorff distance based on the
angular distance in radians from function pygeodesy.thomas_.
|
|
HausdorffVincentys
Compute the Hausdorff distance based on the
angular distance in radians from function pygeodesy.vincentys_.
|
|
Height
Named float representing a height, conventionally in
meter .
|
|
HeightCubic
Height interpolator based on SciPy interp2d kind='cubic' .
|
|
HeightError
Height interpolator Height... or interpolation issue.
|
|
HeightIDW
DEPRECATED, use class HeightIDWeuclidean.
|
|
HeightIDW2
DEPRECATED, use class HeightIDWequirectangular.
|
|
HeightIDW3
DEPRECATED, use class HeightIDWhaversine.
|
|
HeightIDWcosineAndoyerLambert
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function pygeodesy.cosineAndoyerLambert_.
|
|
HeightIDWcosineForsytheAndoyerLambert
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function pygeodesy.cosineForsytheAndoyerLambert_.
|
|
HeightIDWcosineLaw
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function pygeodesy.cosineLaw_.
|
|
HeightIDWdistanceTo
Height interpolator using Inverse Distance Weighting (IDW) and the distance
from the points' LatLon.distanceTo method,
conventionally in meter .
|
|
HeightIDWequirectangular
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians squared like
function pygeodesy.equirectangular_.
|
|
HeightIDWeuclidean
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function pygeodesy.euclidean_.
|
|
HeightIDWflatLocal
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians squared like
function pygeodesy.flatLocal_/pygeodesy.hubeny_.
|
|
HeightIDWflatPolar
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function pygeodesy.flatPolar_.
|
|
HeightIDWhaversine
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function pygeodesy.haversine_.
|
|
HeightIDWhubeny
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians squared like
function pygeodesy.flatLocal_/pygeodesy.hubeny_.
|
|
HeightIDWkarney
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in degrees from
Karney's geographiclib Geodesic Inverse method.
|
|
HeightIDWthomas
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function pygeodesy.thomas_.
|
|
HeightIDWvincentys
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function pygeodesy.vincentys_.
|
|
HeightLSQBiSpline
Height interpolator using SciPy LSQSphereBivariateSpline.
|
|
HeightLinear
Height interpolator based on SciPy interp2d kind='linear' .
|
|
HeightSmoothBiSpline
Height interpolator using SciPy SmoothSphereBivariateSpline.
|
|
Int
Named int .
|
|
Int_
Named int with optional limits low and
high .
|
|
Intersection3Tuple
3-Tuple (point, outside1, outside2) of an intersection
point and outside1 , the position of the
point , -1 if before the start,
+1 if after the end and 0 if on or
between the start and end point of the first line.
|
|
IntersectionError
Error raised for path or circle intersection issues.
|
|
Inverse10Tuple
10-Tuple (a12, s12, salp1, calp1, salp2, calp2, m12, M12,
M21, S12) with arc length a12 in
degrees , distance s12 and reduced length
m12 in meter , area S12 in
meter squared and sines and cosines of initial
and final (forward) azimuths.
|
|
LCCError
Lambert Conformal Conic LCC or other Lcc issue.
|
|
Lam
Named float representing a longitude in
radians .
|
|
Lam_
Named float representing a longitude in
radians converted from degrees .
|
|
LambertEqualArea
Lambert-equal-area projection for the sphere** (aka Lambert zenithal equal-area projection, see Snyder, pp 185-187 and MathWorld-Wolfram.
|
|
Lat
Named float representing a latitude in
degrees .
|
|
LatLon2PsxyIter
Iterate and convert for points with optional loop-back
and copies.
|
|
LatLon2Tuple
2-Tuple (lat, lon) in degrees90 and
degrees180 .
|
|
LatLon2psxy
Wrapper for LatLon points as "on-the-fly"
pseudo-xy coordinates.
|
|
LatLon3Tuple
3-Tuple (lat, lon, height) in degrees90 ,
degrees180 and meter , conventionally.
|
|
LatLon4Tuple
4-Tuple (lat, lon, height, datum) in
degrees90 , degrees180 , meter
and Datum.
|
|
LatLonAziRk4Tuple
4-Tuple (lat, lon, azimuth, reciprocal) , all in
degrees where azimuth is the azimuth of
easting direction and reciprocal the reciprocal of
azimuthal northing scale.
|
|
LatLonDatum3Tuple
3-Tuple (lat, lon, datum) in degrees90 ,
degrees180 and Datum.
|
|
LatLonDatum5Tuple
5-Tuple (lat, lon, datum, convergence, scale) in
degrees90 , degrees180 , Datum,
degrees and float .
|
|
LatLonExact4Tuple
4-Tuple (lat, lon, convergence, scale) in
degrees180 , degrees180 ,
degrees and scalar .
|
|
LatLonPrec3Tuple
3-Tuple (lat, lon, precision) in degrees ,
degrees and int .
|
|
LatLonPrec5Tuple
5-Tuple (lat, lon, precision, height, radius) in
degrees , degrees , int and
height or radius in meter
(or None if missing).
|
|
LatLon_
Low-overhead LatLon class for Numpy2LatLon and Tuple2LatLon.
|
|
Lat_
Named float representing a latitude in
degrees within limits low and
high .
|
|
Lcc
Lambert conformal conic East-/Northing location.
|
|
LenError
Error raised for mis-matching len values.
|
|
LimitError
Error raised for lat- or longitudinal deltas exceeding the
limit in functions pygeodesy.equirectangular and pygeodesy.equirectangular_ and several
nearestOn* and simplify* functions or
methods.
|
|
Local9Tuple
9-Tuple (x, y, z, lat, lon, height, ltp, ecef, M) with
local x , y , z all in
meter , geodetic lat ,
lon , height , local tangent plane
ltp (Ltp), ecef (Ecef9Tuple) with geocentric x ,
y , z , geodetic lat ,
lon , height and concatenated
rotation matrix M (EcefMatrix) or None .
|
|
LocalCartesian
Conversion between geodetic (lat, lon, height) and
local cartesian (x, y, z) coordinates with
geodetic origin (lat0, lon0, height0) ,
transcoded from Karney's C++ class LocalCartesian.
|
|
LocalError
A LocalCartesian or Ltp related
issue.
|
|
Lon
Named float representing a longitude in
degrees .
|
|
Lon_
Named float representing a longitude in
degrees within limits low and
high .
|
|
Ltp
A local tangent plan LTP, a sub-class of
LocalCartesian with configurable ECEF converter and
without optional rotation matrix.
|
|
MGRSError
Military Grid Reference System (MGRS) parse or other Mgrs issue.
|
|
Meeus2Tuple
2-Tuple (radius, Type) with radius and
Meeus' Type of the smallest circle
containing 3 points.
|
|
Meter
Named float representing a distance or length in
meter .
|
|
Meter2
Named float representing an area in meter
squared .
|
|
Meter3
Named float representing a volume in meter
cubed .
|
|
Meter_
Named float representing a distance or length in
meter .
|
|
Mgrs
Military Grid Reference System (MGRS/NATO) references, with method
to convert to UTM coordinates.
|
|
Mgrs4Tuple
4-Tuple (zone, digraph, easting, northing) ,
zone and digraph as str ,
easting and northing in
meter .
|
|
Mgrs6Tuple
6-Tuple (zone, digraph, easting, northing, band,
datum) , zone , digraph and
band as str , easting and
northing in meter and datum
a Datum.
|
|
NearestOn2Tuple
2-Tuple (closest, fraction) of the
closest point on and fraction along a
line (segment) between two points.
|
|
NearestOn3Tuple
3-Tuple (closest, distance, angle) of the
closest point on the polygon, either a
LatLon instance or a LatLon3Tuple(lat, lon, height) and
the distance and angle to the
closest point are in meter respectively
compass degrees360 .
|
|
NearestOn5Tuple
5-Tuple (lat, lon, distance, angle, height) all in
degrees , except height .
|
|
NearestOn6Tuple
6-Tuple (closest, distance, fi, j, start, end) with
the closest point, the distance in
meter , conventionally and the start and
end point of the path or polygon edge.
|
|
NearestOn8Tuple
8-Tuple (closest, distance, fi, j, start, end, initial,
final) , like NearestOn6Tuple but extended with the
initial and the final bearing at the
reference respectively the closest point, both in
compass degrees .
|
|
Ned
Local North-Eeast-Down (NED) location in a local
tangent plane.
|
|
Ned4Tuple
4-Tuple (north, east, down, ltp) , all in
meter except ltp .
|
|
Northing
Named float representing a northing, conventionally in
meter .
|
|
NumPyError
Error raised for NumPy errors.
|
|
Number_
Named int representing a non-negative number.
|
|
Numpy2LatLon
Wrapper for NumPy arrays as "on-the-fly"
LatLon points.
|
|
OSGRError
Ordinance Survey Grid References (OSGR) parse or other Osgr issue.
|
|
Orthographic
Orthographic projection for the sphere**, see Snyder, pp 148-153 and MathWorld-Wolfram.
|
|
Osgr
Ordinance Survey Grid References (OSGR) coordinate.
|
|
PGMError
Issue parsing or cropping an egm*.pgm geoid dataset.
|
|
ParseError
Error parsing degrees, radians or several other formats.
|
|
Phi
Named float representing a latitude in
radians .
|
|
PhiLam2Tuple
2-Tuple (phi, lam) with latitude phi in
radians[PI_2] and longitude lam in
radians[PI] .
|
|
PhiLam3Tuple
3-Tuple (phi, lam, height) with latitude
phi in radians[PI_2] , longitude
lam in radians[PI] and
height in meter .
|
|
PhiLam4Tuple
4-Tuple (phi, lam, height, datum) with latitude
phi in radians[PI_2] , longitude
lam in radians[PI] , height
in meter and Datum.
|
|
Phi_
Named float representing a latitude in
radians converted from degrees .
|
|
Point3Tuple
3-Tuple (x, y, ll) in meter ,
meter and LatLon .
|
|
Points2Tuple
2-Tuple (number, points) with the number
of points and -possible reduced- list or
tuple of points .
|
|
PointsError
Error for an insufficient number of points.
|
|
PointsIter
Iterator for points with optional loop-back and
copies.
|
|
PolygonArea
For geographiclib compatibility, sub-class of GeodesicAreaExact.
|
|
Precision_
Named int with optional low and
high limits representing a precision.
|
|
Property
|
|
Property_RO
|
|
Radians
Named float representing a coordinate in
radians , optionally clipped.
|
|
Radians2
Named float representing a distance in radians
squared .
|
|
Radians_
Named float representing a coordinate in
radians with optional limits low and
high .
|
|
Radical2Tuple
2-Tuple (ratio, xline) of the radical
ratio and radical xline , both
scalar and 0.0 <= ratio <= 1.0
|
|
Radii11Tuple
11-Tuple (rA, rB, rC, cR, rIn, riS, roS, a, b, c, s)
with the Tangent circle radii rA ,
rB and rC , the circumradius
cR , the Incircle radius rIn
aka inradius , the inner and outer Soddy circle
radii riS and roS and the sides
a , b and c and
semi-perimeter s of a triangle, all in
meter conventionally.
|
|
Radius
Named float representing a radius, conventionally in
meter .
|
|
Radius_
Named float with optional low and
high limits representing a radius, conventionally in
meter .
|
|
RangeError
Error raised for lat- or longitude values outside the
clip , clipLat ,
clipLon or limit range in
function pygeodesy.clipDegrees, pygeodesy.clipRadians, pygeodesy.parse3llh, pygeodesy.parseDMS, pygeodesy.parseDMS2 or pygeodesy.parseRad.
|
|
RefFrame
Terrestrial Reference Frame (TRF) parameters.
|
|
RefFrameError
DEPRECATED, use class TRFError.
|
|
ResectionError
Error raised for resection issues.
|
|
Scalar
Named float representing a factor, fraction, scale,
etc.
|
|
Scalar_
Named float with optional low and
high limits representing a factor, fraction, scale,
etc.
|
|
SciPyError
Error raised for SciPy errors.
|
|
SciPyWarning
Error thrown for SciPy warnings.
|
|
Shape2Tuple
2-Tuple (nrows, ncols) , the number of rows and
columns, both int .
|
|
Soddy4Tuple
4-Tuple (radius, center, deltas, outer) with
radius and trilaterated center of the
inner Soddy circle and the radius of the
outer Soddy circle.
|
|
Stereographic
Stereographic projection for the sphere**, see Snyder, pp 157-160 and MathWorld-Wolfram.
|
|
Str
Named str .
|
|
Survey3Tuple
3-Tuple (PA, PB, PC) with distance from survey point
P to each of the triangle corners A ,
B and C .
|
|
TRFError
Terrestrial Reference Frame (TRF), Epoch, RefFrame
or RefFrame conversion issue.
|
|
Tienstra7Tuple
7-Tuple (pointP, A, B, C, a, b, c) with survey
pointP , interior triangle angles A ,
B and C in degrees and
triangle sides a , b and c in
meter , conventionally.
|
|
Transform
Helmert transformation.
|
|
Transform7Tuple
7-Tuple (tx, ty, tz, s, sx, sy, sz) Helmert
transformation with translations tx , ty
and tz in millimeter , scale
s in ppb and rotations sx ,
sy and sz in
milliarcseconds .
|
|
TriAngle4Tuple
4-Tuple (radA, radB, radC, rIn) with the interior
angles at triangle corner A , B and
C and the InCircle radius
rIn aka inradius .
|
|
TriSide2Tuple
2-Tuple (a, radA) with triangle side a
(meter conventionally) and the opposite triangle angle
radA (radians ).
|
|
TriSide4Tuple
4-Tuple (a, b, radC, d) with the length of triangle
sides a and b , the interior angle
radC at triangle corner radC
(radians ) and triangle height d ,
perpendicular to triangle side c .
|
|
Triangle7Tuple
7-Tuple (A, a, B, b, C, c, area) with interior angles
A , B and C in
degrees , spherical sides a ,
b and c in meter and the
area of a spherical triangle in square
meter .
|
|
Triangle8Tuple
8-Tuple (A, a, B, b, C, c, D, E) with interior angles
A , B and C , spherical sides
a , b and c , spherical
deficit D and spherical excess
E of a spherical triangle, all in
radians .
|
|
TriangleError
Error raised for triangle, inter- or resection issues.
|
|
Trilaterate5Tuple
5-Tuple (min, minPoint, max, maxPoint, n) with
min and max in meter , the
corresponding trilaterated minPoint and
maxPoint as LatLon and the number
n .
|
|
Tuple2LatLon
Wrapper for tuple sequences as "on-the-fly"
LatLon points.
|
|
UPSError
Universal Polar Stereographic (UPS) parse or other Ups issue.
|
|
UTMError
Universal Transverse Mercator (UTM parse or other Utm issue.
|
|
UTMUPSError
Universal Transverse Mercator/Universal Polar Stereographic
(UTM/UPS) parse, validate or other issue.
|
|
UnitError
Default exception for units issues.
|
|
Ups
Universal Polar Stereographic (UPS) coordinate.
|
|
Utm
Universal Transverse Mercator (UTM) coordinate.
|
|
UtmUps2Tuple
2-Tuple (zone, hemipole) as int and
str , where zone is 1..60 for
UTM or 0 for UPS and hemipole
'N'|'S' is the UTM hemisphere or the UPS pole.
|
|
UtmUps4Tuple
OBSOLETE, expect a UtmUps5Tuple from method
Mgrs.toUtm(utm=None) .
|
|
UtmUps5Tuple
5-Tuple (zone, hemipole, easting, northing, band) as
int , str , meter ,
meter and band letter, where
zone is 1..60 for UTM or 0
for UPS, hemipole 'N'|'S' is the UTM
hemisphere or the UPS pole and band is
"" or the longitudinal UTM band
'C'|'D'|..|'W'|'X' or polar UPS band
'A'|'B'|'Y'|'Z' .
|
|
UtmUps8Tuple
8-Tuple (zone, hemipole, easting, northing, band, datum,
convergence, scale) as int , str ,
meter , meter , band letter,
Datum , degrees and scalar ,
where zone is 1..60 for UTM or
0 for UPS, hemipole 'N'|'S'
is the UTM hemisphere or the UPS pole and band is
"" or the longitudinal UTM band
'C'|'D'|..|'W'|'X' or polar UPS band
'A'|'B'|'Y'|'Z' .
|
|
UtmUpsLatLon5Tuple
5-Tuple (zone, band, hemipole, lat, lon) as
int , str , str ,
degrees90 and degrees180 , where
zone is 1..60 for UTM or 0
for UPS, band is "" or the
longitudinal UTM band 'C'|'D'|..|'W'|'X' or
polar UPS band 'A'|'B'|'Y'|'Z' and
hemipole 'N'|'S' is the UTM hemisphere or
the UPS pole.
|
|
Vector2Tuple
2-Tuple (x, y) of (geocentric) components, both in
meter or units .
|
|
Vector3Tuple
3-Tuple (x, y, z) of (geocentric) components, all in
meter or units .
|
|
Vector3d
Extended 3-D vector.
|
|
Vector4Tuple
4-Tuple (x, y, z, h) of (geocentric) components, all
in meter or units .
|
|
VectorError
Vector3d, Cartesian* or
*Nvector issues.
|
|
WebMercatorError
Web Mercator (WM) parser or Wm
issue.
|
|
Wm
Web Mercator (WM) coordinate.
|
|
Xyz4Tuple
4-Tuple (x, y, z, ltp) , all in meter
except ltp .
|
|
XyzLocal
Local (x, y, z) in a local tangent plane (LTP)
and base class for local Enu, Ned and
Aer.
|
|
Zone
Named int representing a UTM/UPS zone number.
|
|
a_f2Tuple
2-Tuple (a, f) specifying an ellipsoid by
equatorial radius a in meter and
scalar flattening f .
|
|
property_RO
|
|
|
|
UtmUps(zone,
hemipole,
easting,
northing,
band='',
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
falsed=True,
name='')
Class-like function to create a UTM/UPS coordinate. |
|
|
|
a_b2e(a,
b)
Return e , the 1st eccentricity for a given
equatorial and polar radius. |
|
|
|
a_b2e2(a,
b)
Return e2 , the 1st eccentricity squared for a
given equatorial and polar radius. |
|
|
|
a_b2e22(a,
b)
Return e22 , the 2nd eccentricity squared for a
given equatorial and polar radius. |
|
|
|
a_b2e32(a,
b)
Return e32 , the 3rd eccentricity squared for a
given equatorial and polar radius. |
|
|
|
a_b2f(a,
b)
Return f , the flattening for a given
equatorial and polar radius. |
|
|
|
a_b2f2(a,
b)
Return f2 , the 2nd flattening for a given
equatorial and polar radius. |
|
|
|
a_b2f_(a,
b)
Return f_ , the inverse flattening for a given
equatorial and polar radius. |
|
|
|
a_b2n(a,
b)
Return n , the 3rd flattening for a given
equatorial and polar radius. |
|
|
|
a_f2b(a,
f)
Return b , the polar radius for a given
equatorial radius and flattening. |
|
|
|
a_f_2b(a,
f_)
Return b , the polar radius for a given
equatorial radius and inverse flattening. |
|
|
|
acos1(x)
Return math.acos(max(-1, min(1, x))) . |
|
|
|
acre2ha(acres)
Convert acres to hectare. |
|
|
|
acre2m2(acres)
Convert acres to square meter. |
|
|
|
|
|
anstr(name,
OKd=' ._- ' ,
sub='_')
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. |
|
|
|
|
|
asin1(x)
Return math.asin(max(-1, min(1, x))) . |
|
|
|
atan2b(y,
x)
Return atan2(y, x) in degrees [0..+360]. |
|
|
|
atan2d(y,
x,
reverse=False)
Return atan2(y, x) in degrees [-180..+180], optionally reversed (by 180 degrees
for azi2 ). |
|
|
|
atand(y_x)
Return atan(y_x) angle in degrees . |
|
|
|
attrs(inst,
*names,
**pairs_kwds)
Get instance attributes as name=value strings, with
float s formatted by function fstr. |
|
|
|
b_f2a(b,
f)
Return a , the equatorial radius for a given
polar radius and flattening. |
|
|
|
b_f_2a(b,
f_)
Return a , the equatorial radius for a given
polar radius and inverse flattening. |
|
|
|
bearing(lat1,
lon1,
lat2,
lon2,
**options)
Compute the initial or final bearing (forward or reverse azimuth)
between a (spherical) start and end point. |
|
|
|
bearingDMS(bearing,
form=' d ' ,
prec=None,
sep='')
Convert bearing to a string (without compass point suffix). |
|
|
|
bearing_(phi1,
lam1,
phi2,
lam2,
final=False,
wrap=False)
Compute the initial or final bearing (forward or reverse azimuth)
between a (spherical) start and end point. |
|
|
|
|
|
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. |
|
|
|
cassini(pointA,
pointB,
pointC,
alpha,
beta,
useZ=False,
Clas=None,
**Clas_kwds)
3-Point resection using Cassini's method. |
|
|
|
cbrt(x3)
Compute the cube root x3**(1/3). |
|
|
|
cbrt2(x3)
Compute the cube root squared x3**(2/3). |
|
|
|
centroidOf(points,
wrap=True,
LatLon=None)
Determine the centroid of a polygon. |
|
|
|
chain2m(chains)
Convert UK chains to meter. |
|
|
|
circin6(point1,
point2,
point3,
eps=8.881784197e-16,
useZ=True)
Return the radius and center of the inscribed aka In-
circle of a (2- or 3-D) triangle. |
|
|
|
circle4(earth,
lat)
Get the equatorial or a parallel circle of latitude. |
|
|
|
circum3(point1,
point2,
point3,
circum=True,
eps=8.881784197e-16,
useZ=True)
Return the radius and center of the smallest circle through or
containing three (2- or 3-D) points. |
|
|
|
circum4_(*points,
**Vector_and_kwds)
Best-fit a sphere through three or more (3-D) points. |
|
|
|
classname(inst,
prefixed=None)
Return the instance' class name optionally prefixed with the module
name. |
|
|
|
classnaming(prefixed=None)
Get/set the default class naming for [module.]class
names. |
|
|
|
|
|
clipCS4(points,
lowerleft,
upperright,
closed=False,
inull=False)
Clip a path against a rectangular clip box using the Cohen-Sutherland algorithm. |
|
|
|
|
|
clipDegrees(deg,
limit)
Clip a lat- or longitude to the given range. |
|
|
|
clipLB6(points,
lowerleft,
upperright,
closed=False,
inull=False)
Clip a path against a rectangular clip box using the Liang-Barsky algorithm. |
|
|
|
clipRadians(rad,
limit)
Clip a lat- or longitude to the given range. |
|
|
|
clipSH(points,
corners,
closed=False,
inull=False)
Clip a polygon against a clip region or box using the Sutherland-Hodgman algorithm. |
|
|
|
clipSH3(points,
corners,
closed=False,
inull=False)
Clip a polygon against a clip region or box using the Sutherland-Hodgman algorithm. |
|
|
|
|
|
clips(bstr,
limit=50,
white='')
Clip a string to the given length limit. |
|
|
|
collins(pointA,
pointB,
pointC,
alpha,
beta,
useZ=False,
Clas=None,
**Clas_kwds)
3-Point resection using Collins' method. |
|
|
|
compassAngle(lat1,
lon1,
lat2,
lon2,
adjust=True,
wrap=False)
Return the angle from North for the direction vector (lon2 - lon1, lat2 - lat1) between two points. |
|
|
|
compassDMS(bearing,
form=' d ' ,
prec=None,
sep='')
Convert bearing to a string suffixed with compass point. |
|
|
|
compassPoint(bearing,
prec=3)
Convert bearing to a compass point. |
|
|
|
copysign0(x,
y)
Like math.copysign(x, y) except zero ,
unsigned. |
|
|
|
copytype(x,
y)
Return the value of x as type of y . |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cot(rad,
**error_kwds)
Return the cotangent of an angle in
radians . |
|
|
|
cot_(*rads,
**error_kwds)
Return the cotangent of angle(s) in
radiansresection . |
|
|
|
cotd(deg,
**error_kwds)
Return the cotangent of an angle in
degrees . |
|
|
|
cotd_(*degs,
**error_kwds)
Return the cotangent of angle(s) in
degrees . |
|
|
|
crosserrors(raiser=None)
Report or ignore vectorial cross product errors. |
|
|
|
date2epoch(year,
month,
day)
Return the reference frame epoch for a calendar day. |
|
|
|
|
|
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 an angle to a distance along the equator or along the
parallel at an other (geodetic) latitude. |
|
|
|
degrees360(rad)
Convert radians to degrees and wrap [0..+360). |
|
|
|
degrees90(rad)
Convert radians to degrees and wrap [-270..+90]. |
|
|
|
|
|
deprecated_class(cls_or_class)
Use inside __new__ or __init__ of a DEPRECATED class. |
|
|
|
|
|
|
|
|
|
|
|
elevation2(lat,
lon,
timeout=2.0)
Get the geoid elevation at an NAD83 to
NAVD88 location. |
|
|
|
|
|
|
|
enstr2(easting,
northing,
prec,
*extras)
Return easting, northing string representations. |
|
|
|
epoch2date(epoch)
Return the date for a reference frame epoch . |
|
|
|
|
|
|
|
equirectangular3(lat1,
lon1,
lat2,
lon2,
**options)
DEPRECATED, use function equirectangular_ . |
|
|
|
|
|
euclid(x,
y)
Appoximate the norm sqrt(x**2 + y**2) by
max(abs(x), abs(y)) + min(abs(x), abs(y)) *
0.4142.... |
|
|
|
euclid_(*xs)
Appoximate the norm sqrt(sum(x**2 for x in
xs)) by cascaded euclid. |
|
|
|
euclidean(lat1,
lon1,
lat2,
lon2,
radius=6371008.77141,
adjust=True,
wrap=False)
Approximate the Euclidean distance between two
(spherical) points. |
|
|
|
euclidean_(phi2,
phi1,
lam21,
adjust=True)
Approximate the angular Euclidean distance
between two (spherical) points. |
|
|
|
exception_chaining(error=None)
Get the previous exception's or exception chaining setting. |
|
|
|
excessAbc(A,
b,
c)
Compute the spherical excess E of a (spherical)
triangle from two sides and the included angle. |
|
|
|
excessGirard(A,
B,
C)
Compute the spherical excess E of a (spherical)
triangle using Girard's formula. |
|
|
|
excessKarney(lat1,
lon1,
lat2,
lon2,
radius=6371008.77141,
wrap=False)
Compute the surface area of a (spherical) quadrilateral bounded by a
segment of a great circle, two meridians and the equator using Karney's method. |
|
|
|
excessKarney_(phi2,
phi1,
lam21)
Compute the spherical excess E of a (spherical)
quadrilateral bounded by a segment of a great circle, two meridians
and the equator using Karney's method. |
|
|
|
|
|
excessQuad(lat1,
lon1,
lat2,
lon2,
radius=6371008.77141,
wrap=False)
Compute the surface area of a (spherical) quadrilateral bounded by a
segment of a great circle, two meridians and the equator. |
|
|
|
excessQuad_(phi2,
phi1,
lam21)
Compute the spherical excess E of a (spherical)
quadrilateral bounded by a segment of a great circle, two meridians
and the equator. |
|
|
|
f2e2(f)
Return e2 , the 1st eccentricity squared for a
given flattening. |
|
|
|
f2e22(f)
Return e22 , the 2nd eccentricity squared for a
given flattening. |
|
|
|
f2e32(f)
Return e32 , the 3rd eccentricity squared for a
given flattening. |
|
|
|
f2f2(f)
Return f2 , the 2nd flattening for a given
flattening. |
|
|
|
f2f_(f)
Return f_ , the inverse flattening for a given
flattening. |
|
|
|
f2n(f)
Return n , the 3rd flattening for a given
flattening. |
|
|
|
fStr(floats,
prec=6,
fmt='f',
ints=False,
sep=', ')
DEPRECATED, use function fstr. |
|
|
|
|
|
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. |
|
|
|
|
|
fatan(x)
Fast approximation of atan(x) . |
|
|
|
fatan1(x)
Fast approximation of atan(x) for 0 <=
x <= 1 , unchecked. |
|
|
|
fatan2(y,
x)
Fast approximation of atan2(y, x) . |
|
|
|
fathom2m(fathoms)
Convert UK fathom to meter. |
|
|
|
favg(v1,
v2,
f=0.5)
Return the average of two values. |
|
|
|
fdot(a,
*b)
Return the precision dot product sum(a[i] * b[i] for
i=0..len(a)). |
|
|
|
fdot3(a,
b,
c,
start=0)
Return the precision dot product start + sum(a[i] *
b[i] * c[i] for i=0..len(a)). |
|
|
|
fhorner(x,
*cs)
Evaluate the polynomial sum(cs[i] * x**i for
i=0..len(cs)) using the Horner form. |
|
|
|
|
|
|
|
|
|
|
|
|
|
fmean(xs)
Compute the accurate mean sum(xs[i] for i=0..len(xs))
/ len(xs). |
|
|
|
fmean_(*xs)
Compute the accurate mean sum(xs[i] for i=0..len(xs))
/ len(xs). |
|
|
|
fpolynomial(x,
*cs)
Evaluate the polynomial sum(cs[i] * x**i for
i=0..len(cs)). |
|
|
|
fpowers(x,
n,
alts=0)
Return a series of powers [x**i for i=1..n]. |
|
|
|
fprod(iterable,
start=1.0)
Iterable product, like math.prod or
numpy.prod . |
|
|
|
fractional(points,
fi,
j=None,
wrap=None,
LatLon=None,
Vector=None,
**kwds)
Return the point at a given fractional index. |
|
|
|
frange(start,
number,
step=1)
Generate a range of 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. |
|
|
|
fsum1(iterable)
Precision summation, primed with 1.0 . |
|
|
|
fsum1_(*xs)
Precision summation of a few arguments, primed with 1.0 . |
|
|
|
fsum_(*xs)
Precision summation of all positional arguments. |
|
|
|
ft2m(feet,
usurvey=False)
Convert International or US Survey feet to meter. |
|
|
|
furlong2m(furlongs)
Convert a furlong to meter. |
|
|
|
geoidHeight2(lat,
lon,
model=0,
timeout=2.0)
Get the NAVD88 geoid height at an NAD83
location. |
|
|
|
|
|
grades(rad)
Convert radians to grades (aka gons or
gradians). |
|
|
|
|
|
|
|
grades400(rad)
Convert radians to grades (aka gons or gradians)
and wrap [0..+400). |
|
|
|
halfs2(str2)
Split a string in 2 halfs. |
|
|
|
hartzell(pov,
los=None,
earth=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
LatLon=None,
**LatLon_kwds)
Compute the intersection of a Line-Of-Sight from a Point-Of-View in
space with the surface of the earth. |
|
|
|
hausdorff_(model,
target,
both=False,
early=True,
seed=None,
units='',
distance=None,
point=<function _point at 0x7fcab84cc850>)
Compute the directed or symmetric Hausdorff distance between 2 sets of points with or
without early breaking and random sampling. |
|
|
|
haversine(lat1,
lon1,
lat2,
lon2,
radius=6371008.77141,
wrap=False)
Compute the distance between two (spherical) points using the Haversine formula. |
|
|
|
haversine_(phi2,
phi1,
lam21)
Compute the angular distance between two (spherical) points
using the Haversine formula. |
|
|
|
heightOf(angle,
distance,
radius=6371008.77141)
Determine the height above the (spherical) earth' surface after
traveling along a straight line at a given tilt. |
|
|
|
horizon(height,
radius=6371008.77141,
refraction=False)
Determine the distance to the horizon from a given altitude above the
(spherical) earth. |
|
|
|
hstr(height,
prec=2,
fmt='%+.*f',
ints=False,
m='')
Return a string for the height value. |
|
|
|
|
|
|
|
hypot(x,
y)
Return the Euclidean distance, sqrt(x*x + y*y). |
|
|
|
hypot1(x)
Compute the norm sqrt(1 + x**2). |
|
|
|
hypot2(x,
y)
Compute the squared norm x**2 + y**2. |
|
|
|
hypot2_(*xs)
Compute the squared norm sum(x**2 for x in
xs) . |
|
|
|
|
|
hypot_(*xs)
Compute the norm sqrt(sum(x**2 for x in xs)). |
|
|
|
|
|
instr(inst,
*args,
**kwds)
Return the string representation of an instantiation. |
|
|
|
intersection3d3(start1,
end1,
start2,
end2,
eps=2.22044604925e-16,
useZ=True,
**Vector_and_kwds)
Compute the intersection point of two lines, each defined by or
through a start and end point (3-D). |
|
|
|
intersections2(center1,
radius1,
center2,
radius2,
sphere=True,
**Vector_and_kwds)
Compute the intersection of two spheres or circles, each defined by a
(3-D) center point and a radius. |
|
|
|
isNumpy2(obj)
Check for an Numpy2LatLon points wrapper. |
|
|
|
isPoints2(obj)
Check for an LatLon2psxy points wrapper. |
|
|
|
isTuple2(obj)
Check for an Tuple2LatLon points wrapper. |
|
|
|
isantipode(lat1,
lon1,
lat2,
lon2,
eps=2.22044604925e-16)
Check whether two points are antipodal, on diametrically opposite
sides of the earth. |
|
|
|
isantipode_(phi1,
lam1,
phi2,
lam2,
eps=2.22044604925e-16)
Check whether two points are antipodal, on diametrically opposite
sides of the earth. |
|
|
|
isbool(obj)
Check whether an object is bool ean. |
|
|
|
isclass(obj)
Return True if obj is a
class . |
|
|
|
isclockwise(points,
adjust=False,
wrap=True)
Determine the direction of a path or polygon. |
|
|
|
iscolinearWith(point,
point1,
point2,
eps=2.22044604925e-16,
useZ=True)
Check whether a point is colinear with two other (2- or 3-D) points. |
|
|
|
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. |
|
|
|
|
|
isfinite(obj)
Check for Inf and NaN values. |
|
|
|
isidentifier(obj)
Return True if obj is a valid Python
identifier. |
|
|
bool
|
isinf(x)
Check if float x is infinite (positive or negative). |
|
|
|
isint(obj,
both=False)
Check for int type or an integer float
value. |
|
|
|
|
bool
|
isnan(x)
Check if float x is not a number (NaN). |
|
|
|
isnear0(x,
eps0=4.93038065763e-32)
Is x near zero? |
|
|
|
isnear1(x,
eps0=4.93038065763e-32)
Is x near one? |
|
|
|
isneg0(x)
Check for NEG0, negative 0.0 . |
|
|
|
isnon0(x,
eps0=4.93038065763e-32)
Is x non-zero? |
|
|
|
|
|
ispolar(points,
wrap=False)
Check whether a polygon encloses a pole. |
|
|
|
|
|
issequence(obj,
*excluded)
Check for sequence types. |
|
|
|
isstr(obj)
Check for string types. |
|
|
|
issubclassof(Sub,
*Supers)
Check whether a class is a sub-class of some class(es). |
|
|
|
iterNumpy2(obj)
Iterate over Numpy2 wrappers or other sequences exceeding the
threshold. |
|
|
|
|
|
joined(*words,
**sep)
DEPRECATED, use NN(...) , NN.join_ or
sep.join . |
|
|
|
joined_(*words,
**sep)
DEPRECATED, use _SPACE_(...) , _SPACE_.join_
or sep.join , sep=" ". |
|
|
|
latDMS(deg,
form=' dms ' ,
prec=2,
sep='')
Convert latitude to a string, optionally suffixed with N or S. |
|
|
|
latlon2n_xyz(lat,
lon,
name='')
Convert lat-, longitude to n-vector (normal to the
earth's surface) X, Y and Z components. |
|
|
|
latlonDMS(lls,
form=' dms ' ,
prec=None,
sep=None)
Convert one or more LatLon instances to strings. |
|
|
|
latlonDMS_(*lls,
**form_prec_sep)
Convert one or more LatLon instances to strings. |
|
|
|
len2(items)
Make built-in function len work for
generators, iterators, etc. |
|
|
|
|
|
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). |
|
|
|
m2chain(meter)
Convert meter to UK chains. |
|
|
|
m2degrees(distance,
radius=6371008.77141,
lat=0)
Convert a distance to an angle along the equator or along the
parallel at an other (geodetic) latitude. |
|
|
|
m2fathom(meter)
Convert meter to UK fathoms. |
|
|
|
m2ft(meter,
usurvey=False)
Convert meter to International or US Survey feet
(ft ). |
|
|
|
|
|
m2km(meter)
Convert meter to kilo meter (km). |
|
|
|
m2radians(distance,
radius=6371008.77141,
lat=0)
Convert a distance to an angle along the equator or along the
parallel at an other (geodetic) latitude. |
|
|
|
|
|
m2yard(meter)
Convert meter to UK yards. |
|
|
|
machine()
Return standard platform.machine , but distinguishing
Intel from Intel emulation on Apple Silicon (on macOS only). |
|
|
|
map1(fun1,
*xs)
Apply each argument to a single-argument function and return a
tuple of results. |
|
|
|
map2(func,
*xs)
Apply arguments to a function and return a tuple of
results. |
|
|
|
meeus2(point1,
point2,
point3,
circum=False,
useZ=True)
Return the radius and Meeus' Type of the smallest circle
through or containing three (2- or 3-D) points. |
|
|
|
modulename(clas,
prefixed=None)
Return the class name optionally prefixed with the module name. |
|
|
|
n2e2(n)
Return e2 , the 1st eccentricity squared for a
given 3rd flattening. |
|
|
|
n2f(n)
Return f , the flattening for a given 3rd
flattening. |
|
|
|
n2f_(n)
Return f_ , the inverse flattening for a given
3rd flattening. |
|
|
|
n_xyz2latlon(x,
y,
z,
name='')
Convert n-vector components to lat- and longitude in
degrees . |
|
|
|
n_xyz2philam(x,
y,
z,
name='')
Convert n-vector components to lat- and longitude in
radians . |
|
|
|
nameof(inst)
Get the name of an instance. |
|
|
|
nearestOn(point,
point1,
point2,
within=True,
useZ=True,
Vector=None,
**Vector_kwds)
Locate the point between two points closest to a reference (2- or
3-D). |
|
|
|
|
|
|
|
nearestOn5(point,
points,
closed=False,
wrap=False,
LatLon=None,
**options)
Locate the point on a path or polygon closest to a reference point. |
|
|
|
nearestOn6(point,
points,
closed=False,
useZ=True,
**Vector_and_kwds)
Locate the point on a path or polygon closest to a reference point. |
|
|
|
neg(x)
Negate x unless zero or NEG0 . |
|
|
|
neg_(*xs)
Negate all of xs with neg. |
|
|
|
norm2(x,
y)
Normalize a 2-dimensional vector. |
|
|
|
normDMS(strDMS,
norm=None)
Normalize all degree, minute and second DMS symbols in a string to
the default DMS symbols '\xc2\xb0', '\xe2\x80\xb2' and
'\xe2\x80\xb3'. |
|
|
|
norm_(*xs)
Normalize all n-dimensional vector components. |
|
|
|
notImplemented(inst,
*args,
**kwds)
Raise a NotImplementedError for a missing method or
property. |
|
|
|
notOverloaded(inst,
*args,
**kwds)
Raise an AssertionError for a method or property not
overloaded. |
|
|
|
opposing(bearing1,
bearing2,
margin=None)
Compare the direction of two bearings given in degrees . |
|
|
|
opposing_(radians1,
radians2,
margin=None)
Compare the direction of two bearings given in radians . |
|
|
|
pairs(items,
prec=6,
fmt='F',
ints=False,
sep='=')
Convert items to name=value strings, with float s
handled like fstr. |
|
|
|
parse3d(str3d,
sep=',',
Vector=<class 'pygeodesy.vector3d.Vector3d'>,
**Vector_kwds)
Parse an "x, y, z" string. |
|
|
|
parse3llh(strllh,
height=0,
sep=',',
clipLat=90,
clipLon=180)
Parse a string "lat lon [h]" representing
lat-, longitude in degrees and optional height in
meter . |
|
|
|
parseDDDMMSS(strDDDMMSS,
suffix=' NSEW ' ,
sep='',
clip=0,
sexagecimal=False)
Parse a lat- or longitude represention forms as [D]DDMMSS in degrees. |
|
|
|
parseDMS(strDMS,
suffix=' NSEW ' ,
sep='',
clip=0)
Parse a lat- or longitude representation in degrees . |
|
|
|
parseDMS2(strLat,
strLon,
sep='',
clipLat=90,
clipLon=180)
Parse a lat- and a longitude representions "lat,
lon" in degrees . |
|
|
|
parseETM5(strUTM,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Etm=<class 'pygeodesy.etm.Etm'>,
falsed=True,
name='')
Parse a string representing a UTM coordinate, consisting of
"zone[band] hemisphere easting northing" . |
|
|
|
parseMGRS(strMGRS,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Mgrs=<class 'pygeodesy.mgrs.Mgrs'>,
name='')
Parse a string representing a MGRS grid reference, consisting of
"zoneBand, grid, easting, northing" . |
|
|
|
parseOSGR(strOSGR,
Osgr=<class 'pygeodesy.osgr.Osgr'>,
name='')
Parse a string representing an OSGR grid reference, consisting of
"[grid] easting northing" . |
|
|
|
parseRad(strRad,
suffix=' NSEW ' ,
clip=0)
Parse a string representing angle in radians . |
|
|
|
parseUPS5(strUPS,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Ups=<class 'pygeodesy.ups.Ups'>,
falsed=True,
name='')
Parse a string representing a UPS coordinate, consisting of
"[zone][band] pole easting northing" where
zone is pseudo zone
"00"|"0"|"" and
band is 'A'|'B'|'Y'|'Z'|'' . |
|
|
|
|
|
parseUTM5(strUTM,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Utm=<class 'pygeodesy.utm.Utm'>,
falsed=True,
name='')
Parse a string representing a UTM coordinate, consisting of
"zone[band] hemisphere easting northing" . |
|
|
|
parseUTMUPS5(strUTMUPS,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Utm=<class 'pygeodesy.utm.Utm'>,
Ups=<class 'pygeodesy.ups.Ups'>,
name='')
Parse a string representing a UTM or UPS coordinate, consisting of
"zone[band] hemisphere/pole easting northing" . |
|
|
|
parseWM(strWM,
radius=6378137.0,
Wm=<class 'pygeodesy.webmercator.Wm'>,
name='')
Parse a string "e n [r]" representing a WM
coordinate, consisting of easting, northing and an optional radius. |
|
|
|
perimeterOf(points,
closed=False,
adjust=True,
radius=6371008.77141,
wrap=True)
Approximate the perimeter of a path or polygon. |
|
|
|
perimeterof(points,
closed=False,
adjust=True,
radius=6371008.77141,
wrap=True)
DEPRECATED, use function perimeterOf. |
|
|
|
philam2n_xyz(phi,
lam,
name='')
Convert lat-, longitude to n-vector (normal to the
earth's surface) X, Y and Z components. |
|
|
|
pierlot(point1,
point2,
point3,
alpha12,
alpha23,
useZ=False,
Clas=None,
**Clas_kwds)
3-Point resection using Pierlot's method ToTal . |
|
|
|
points2(points,
closed=True,
base=None,
Error=<class 'pygeodesy.errors.PointsError'>)
Check a path or polygon represented by points. |
|
|
|
polygon(points,
closed=True,
base=None)
DEPRECATED, use function points2. |
|
|
|
precision(form,
prec=None)
Set the default precison for a given F_ form. |
|
|
|
print_(*args,
**nl_nt_prefix_end_file_flush_sep)
Python 3-style print function. |
|
|
|
printf(fmt,
*args,
**nl_nt_prefix_end_file_flush_sep)
C-style printf function. |
|
|
|
property_doc_(doc)
Decorator for a standard property with basic
documentation. |
|
|
|
quadOf(latS,
lonW,
latN,
lonE,
closed=False,
LatLon=<class 'pygeodesy.points.LatLon_'>,
**LatLon_kwds)
Generate a quadrilateral path or polygon from two points. |
|
|
|
radians(x)
Convert angle x from degrees to radians. |
|
|
|
radians2m(rad,
radius=6371008.77141,
lat=0)
Convert an angle to a distance along the equator or along the
parallel at an other (geodetic) latitude. |
|
|
|
radiansPI(deg)
Convert and wrap degrees to radians [-PI..+PI]. |
|
|
|
radiansPI2(deg)
Convert and wrap degrees to radians [0..+2PI). |
|
|
|
radiansPI_2(deg)
Convert and wrap degrees to radians [-3PI/2..+PI/2]. |
|
|
|
|
|
radii11(point1,
point2,
point3,
useZ=True)
Return the radii of the In- , Soddy and
Tangent circles of a (2- or 3-D) triangle. |
|
|
|
|
|
|
|
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_. |
|
|
|
signOf(x)
Return sign of x as int . |
|
|
|
simplify1(points,
distance=0.001,
radius=6371008.77141,
indices=False,
**options)
Basic simplification of a path of LatLon points. |
|
|
|
|
|
simplifyRDP(points,
distance=0.001,
radius=6371008.77141,
shortest=False,
indices=False,
**options)
Ramer-Douglas-Peucker (RDP) simplification of a path of
LatLon points. |
|
|
|
simplifyRDPm(points,
distance=0.001,
radius=6371008.77141,
shortest=False,
indices=False,
**options)
Modified Ramer-Douglas-Peucker (RDPm) simplification of a path of
LatLon points. |
|
|
|
simplifyRW(points,
pipe=0.001,
radius=6371008.77141,
shortest=False,
indices=False,
**options)
Reumann-Witkam (RW) simplification of a path of LatLon
points. |
|
|
|
simplifyVW(points,
area=0.001,
radius=6371008.77141,
attr=None,
indices=False,
**options)
Visvalingam-Whyatt (VW) simplification of a path of
LatLon points. |
|
|
|
simplifyVWm(points,
area=0.001,
radius=6371008.77141,
attr=None,
indices=False,
**options)
Modified Visvalingam-Whyatt (VWm) simplification of a path of
LatLon points. |
|
|
|
sincos2(rad)
Return the sine and cosine of an angle in
radians . |
|
|
|
sincos2_(*rads)
Return the sine and cosine of angle(s) in
{Cradians}. |
|
|
|
sincos2d(deg)
Return the sine and cosine of an angle in
degrees . |
|
|
|
sincos2d_(*degs)
Return the sine and cosine of angle(s) in
degrees . |
|
|
|
|
|
soddy4(point1,
point2,
point3,
eps=8.881784197e-16,
useZ=True)
Return the radius and center of the inner Soddy
circle of a (2- or 3-D) triangle. |
|
|
|
splice(iterable,
n=2,
**fill)
Split an iterable into n slices. |
|
|
|
sqrt0(x2)
Compute the square root iff x2 > EPS02. |
|
|
|
sqrt3(x2)
Compute the square root, cubed sqrt(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,
**semi)
Compute the tangent of half angle. |
|
|
|
tand(deg,
**error_kwds)
Return the tangent of an angle in degrees . |
|
|
|
tand_(*degs,
**error_kwds)
Return the tangent of angle(s) in degrees . |
|
|
|
thomas(lat1,
lon1,
lat2,
lon2,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
wrap=False)
Compute the distance between two (ellipsoidal) points using Thomas' formula. |
|
|
|
thomas_(phi2,
phi1,
lam21,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... )
Compute the angular distance between two (ellipsoidal) points
using Thomas' formula. |
|
|
|
tienstra(pointA,
pointB,
pointC,
alpha,
beta=None,
gamma=None,
useZ=False,
Clas=None,
**Clas_kwds)
3-Point resection using Tienstra's formula. |
|
|
|
toCss(latlon,
cs0=None,
height=None,
Css=<class 'pygeodesy.css.Css'>,
name='')
Convert an (ellipsoidal) geodetic point to a Cassini-Soldner
location. |
|
|
|
toDMS(deg,
form=' dms ' ,
prec=2,
sep='',
ddd=2,
neg='-',
pos='')
Convert signed degrees to string, without suffix. |
|
|
|
toEtm8(latlon,
lon=None,
datum=None,
Etm=<class 'pygeodesy.etm.Etm'>,
falsed=True,
name='',
zone=None,
**cmoff)
Convert a lat-/longitude point to an ETM coordinate. |
|
|
|
toLcc(latlon,
conic=Conic(name='WRF_Lb', lat0=40, lon0=-97, par1=33, par2=45, E0=0... ,
height=None,
Lcc=<class 'pygeodesy.lcc.Lcc'>,
name='',
**Lcc_kwds)
Convert an (ellipsoidal) geodetic point to a Lambert location. |
|
|
|
toMgrs(utm,
Mgrs=<class 'pygeodesy.mgrs.Mgrs'>,
name='',
**Mgrs_kwds)
Convert a UTM coordinate to an MGRS grid reference. |
|
|
|
toOsgr(latlon,
lon=None,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Osgr=<class 'pygeodesy.osgr.Osgr'>,
name='',
**Osgr_kwds)
Convert a lat-/longitude point to an OSGR coordinate. |
|
|
|
toUps8(latlon,
lon=None,
datum=None,
Ups=<class 'pygeodesy.ups.Ups'>,
pole='',
falsed=True,
strict=True,
name='')
Convert a lat-/longitude point to a UPS coordinate. |
|
|
|
toUtm(latlon,
lon=None,
datum=None,
Utm=_UTM,
cmoff=True,
name='')
DEPRECATED, use function pygeodesy.toUtm8. |
|
|
|
toUtm8(latlon,
lon=None,
datum=None,
Utm=<class 'pygeodesy.utm.Utm'>,
falsed=True,
name='',
zone=None,
**cmoff)
Convert a lat-/longitude point to a UTM coordinate. |
|
|
|
toUtmUps8(latlon,
lon=None,
datum=None,
falsed=True,
Utm=<class 'pygeodesy.utm.Utm'>,
Ups=<class 'pygeodesy.ups.Ups'>,
pole='',
name='',
**cmoff)
Convert a lat-/longitude point to a UTM or UPS coordinate. |
|
|
|
toWm(latlon,
lon=None,
radius=6378137.0,
Wm=<class 'pygeodesy.webmercator.Wm'>,
name='',
**Wm_kwds)
Convert a lat-/longitude point to a WM coordinate. |
|
|
|
|
|
trfXform(reframe1,
reframe2,
epoch=None,
xform=None,
rates=None)
Define a new Terrestrial Reference Frame (TRF) conversion. |
|
|
|
triAngle(a,
b,
c)
Compute an interior angle of a triangle. |
|
|
|
triAngle4(a,
b,
c)
Compute the angles of a triangle side. |
|
|
|
triSide(a,
b,
radC)
Compute the length of a triangle side. |
|
|
|
triSide2(b,
c,
radB)
Compute the length of a triangle side and the angle. |
|
|
|
triSide4(radA,
radB,
c)
Compute the length of two triangle sides and the triangle height. |
|
|
|
trilaterate2d2(x1,
y1,
radius1,
x2,
y2,
radius2,
x3,
y3,
radius3,
eps=None,
**Vector_and_kwds)
Trilaterate three circles, each given as a (2-D) center and a radius. |
|
|
|
trilaterate3d2(center1,
radius1,
center2,
radius2,
center3,
radius3,
eps=2.22044604925e-16,
**Vector_and_kwds)
Trilaterate three spheres, each given as a (3-D) center and a radius. |
|
|
|
tyr3d(tilt=0,
yaw=0,
roll=0,
Vector=<class 'pygeodesy.vector3d.Vector3d'>,
**Vector_kwds)
Convert an attitude oriention into a (3-D) direction vector. |
|
|
|
ub2str(ub)
Convert unicode or bytes to
str . |
|
|
|
|
|
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(named,
*args,
**kwds)
Return the string representation of an invokation. |
|
|
|
upsZoneBand5(lat,
lon,
strict=True,
name='')
Return the UTM/UPS zone number, polar Band letter, pole and
clipped lat- and longitude for a given location. |
|
|
|
|
|
utmZoneBand5(lat,
lon,
cmoff=False,
name='')
Return the UTM zone number, Band letter, hemisphere and (clipped)
lat- and longitude for a given location. |
|
|
|
utmupsValidate(coord,
falsed=False,
MGRS=False,
Error=<class 'pygeodesy.utmups.UTMUPSError'>)
Check a UTM or UPS coordinate. |
|
|
|
|
|
utmupsZoneBand5(lat,
lon,
cmoff=False,
name='')
Return the UTM/UPS zone number, Band letter, hemisphere/pole and
clipped lat- and longitude for a given location. |
|
|
|
vincentys(lat1,
lon1,
lat2,
lon2,
radius=6371008.77141,
wrap=False)
Compute the distance between two (spherical) points using Vincenty's spherical formula. |
|
|
|
vincentys_(phi2,
phi1,
lam21)
Compute the angular distance between two (spherical) points
using Vincenty's spherical formula. |
|
|
|
|
|
wrap180(deg)
Wrap degrees to [-180..+180]. |
|
|
|
wrap360(deg)
Wrap degrees to [0..+360). |
|
|
|
wrap90(deg)
Wrap degrees to [-270..+90]. |
|
|
|
wrapPI(rad)
Wrap radians to [-PI..+PI]. |
|
|
|
wrapPI2(rad)
Wrap radians to [0..+2PI). |
|
|
|
wrapPI_2(rad)
Wrap radians to [-3PI/2..+PI/2]. |
|
|
|
yard2m(yards)
Convert UK yards to meter. |
|
|