A pure Python implementation of geodesy tools for various ellipsoidal
and spherical earth models using precision trigonometric, vector-based,
exact, elliptic, iterative and approximate methods for geodetic
(lat-/longitude), geocentric (ECEF cartesian) and certain triaxial ellipsoidal coordinates.
Previously, the tests were run with Python 3.13.0, 3.12.0-6,
3.11.2-4, 3.10.1-7, 3.9.6, 3.9.1, 3.8.7, 3.7.1, 2.7.15, PyPy 7.3.12 (Python 3.10.12),
7.3.1 (Python 3.6.9) and PyPy 7.1.1 (Python 2.7.13) (and geographiclib 1.52, numpy 1.16.3,
1.16.4, 1.16.6, 1.19.0, 1.19.4, 1.19.5 or 1.22.4 and scipy 1.2.1,
1.4.1, 1.5.2 or 1.8.1) on Ubuntu
16.04, with Python 3.10.0-1, 3.9.0-5, 3.8.0-6, 3.7.2-6, 3.7.0,
3.6.2-5, 3.5.3, 2.7.13-17, 2.7.10 and 2.6.9 (and numpy 1.19.0,
1.16.5, 1.16.2, 1.15.2, 1.14.0, 1.13.1, 1.8.0rc1 or 1.6.2 and scipy 1.5.0),
PyPy 7.3.0 (Python 2.7.13
and 3.6.9), PyPy 6.0.0
(Python 2.7.13 and 3.5.3) and Intel-Python 3.5.3 (and numpy 1.11.3)
on macOS 14.0-5 Sonoma, 13.0-5.2 Ventura, 12.1-6 Monterey, 11.0-5.2-6.1
Big Sur (aka 10.16), 10.15.3, 10.15.5-7 Catalina, 10.14 Mojave, 10.13.6
High Sierra and 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, iPhone10
and/or iPhone12, 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
Server 2012R2, Windows 10 Pro and with 32-bit Python 2.6.6 on Windows
XP SP3.
|
|
ADict
A dict with both key and attribute access to
the dict items.
|
|
|
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.
|
|
|
Area3Tuple
3-Tuple (number, perimeter, area) with the
number of points of the polygon or polyline, the
perimeter in meter and the
area in meter squared.
|
|
|
Attitude
The pose 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.
|
|
|
AuxError
Error raised for a rhumb.aux_,
Aux, AuxDLat or AuxLat
issue.
|
|
|
Azimuth
Named float representing an azimuth in compass
degrees from (true) North.
|
|
|
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.
|
|
|
BetaOmega2Tuple
2-Tuple (beta, omega) with ellipsoidal lat- and
longitude beta and omega both in Radians
(or Degrees).
|
|
|
BetaOmega3Tuple
3-Tuple (beta, omega, height) with ellipsoidal
lat- and longitude beta and omega both in
Radians (or Degrees)
and the height, rather the (signed) distance to
the triaxial's surface (measured along the radial line to the
triaxial's center) in meter, conventionally.
|
|
|
Bool
Named bool, a sub-class of int like
Python's bool.
|
|
|
BooleanFHP
Composite class providing boolean operations between
two composites using Forster-Hormann-Popa's C++ implementation,
transcoded to pure Python.
|
|
|
BooleanGH
Composite class providing boolean operations between
two composites using the Greiner-Hormann algorithm and Correia's implementation, modified and extended.
|
|
|
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.
|
|
|
ChLV
Conversion between WGS84 geodetic and Swiss
projection coordinates using pygeodesy.EcefKarney's Earth-Centered, Earth-Fixed
(ECEF) methods.
|
|
|
ChLV9Tuple
9-Tuple (Y, X, h_, lat, lon, height, ltp, ecef, M)
with unfalsed Swiss (Y, X, h_) coordinates and
height, all in meter, ltp either a ChLV, ChLVa or ChLVe
instance and ecef (EcefKarney at Bern, Ch), otherwise like Local9Tuple.
|
|
|
ChLVEN2Tuple
2-Tuple (E_LV95, N_LV95) with falsed Swiss
LV95 easting and norting in meter (2_600_000,
1_200_000) and origin at Bern, Ch.
|
|
|
ChLVYX2Tuple
2-Tuple (Y, X) with unfalsed Swiss LV95
easting and norting in meter.
|
|
|
ChLVa
Conversion between WGS84 geodetic and Swiss
projection coordinates using the Approximate formulas, page 13.
|
|
|
ChLVe
Conversion between WGS84 geodetic and Swiss
projection coordinates using the Ellipsoidal approximate formulas, pp 10-11 and Bolliger, J. pp 148-151 (also GGGS).
|
|
|
ChLVyx2Tuple
2-Tuple (y_LV03, x_LV03) with falsed Swiss
LV03 easting and norting in meter (600_000,
200_000) and origin at Bern, Ch.
|
|
|
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
DEPRECATED, see DEPRECATED function pygeodesy.deprecated.clipCS3.
|
|
|
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.
|
|
|
ClipFHP4Tuple
4-Tuple (lat, lon, height, clipid) for each point of
the clipFHP4 result with the lat-,
longitude, height and clipid
of the polygon or clip.
|
|
|
ClipGH4Tuple
4-Tuple (lat, lon, height, clipid) for each point of
the clipGH4 result with the lat-,
longitude, height and clipid
of the polygon or clip.
|
|
|
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, lines 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.
|
|
|
DivMod2Tuple
2-Tuple (div, mod) with the quotient div
and remainder mod results of a divmod
operation.
|
|
|
EPSGError
EPSG encode, decode or other Epsg issue.
|
|
|
ETMError
Exact Transverse Mercator (ETM) parse, projection or other Etm issue or
ExactTransverseMercator conversion failure.
|
|
|
EasNor2Tuple
2-Tuple (easting, northing), both in
meter, conventionally.
|
|
|
EasNor3Tuple
3-Tuple (easting, northing, height), all in
meter, conventionally.
|
|
|
EasNorAziRk4Tuple
4-Tuple (easting, northing, azimuth, reciprocal) for
the Cassini-Soldner location with easting and
northing in meters and the
azimuth of easting direction and
reciprocal of azimuthal northing scale, both in
degrees.
|
|
|
EasNorAziRkEqu6Tuple
6-Tuple (easting, northing, azimuth, reciprocal, equatorarc,
equatorazimuth) for the Cassini-Soldner location with
easting and northing in
meters and the azimuth of easting
direction, reciprocal of azimuthal northing scale,
equatorarc and equatorazimuth, all in
degrees.
|
|
|
EasNorExact4Tuple
DEPRECATED, use class Forward4Tuple, item gamma for
convergence.
|
|
|
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, rotation matrix
M (EcefMatrix) and datum, with
lat and lon in degrees and
x, y, z and
height in meter, conventionally.
|
|
|
EcefError
An ECEF or Ecef* related issue.
|
|
|
EcefFarrell21
Conversion between geodetic and geocentric, Earth-Centered,
Earth-Fixed (ECEF) coordinates based on Jay A. Farrell's
Table 2.1, page 29.
|
|
|
EcefFarrell22
Conversion between geodetic and geocentric, Earth-Centered,
Earth-Fixed (ECEF) coordinates based on Jay A. Farrell's
Table 2.2, page 30.
|
|
|
EcefKarney
Conversion between geodetic and geocentric, Earth-Centered,
Earth-Fixed (ECEF) coordinates transcoded from Karney's
C++ Geocentric methods.
|
|
|
EcefMatrix
A rotation matrix known as East-North-Up (ENU) to ECEF.
|
|
|
EcefSudano
Conversion between geodetic and geocentric, Earth-Centered,
Earth-Fixed (ECEF) coordinates based on John J. Sudano's
paper.
|
|
|
EcefVeness
Conversion between geodetic and geocentric, Earth-Centered,
Earth-Fixed (ECEF) coordinates transcoded from Chris
Veness' JavaScript classes LatLonEllipsoidal, Cartesian.
|
|
|
EcefYou
Conversion between geodetic and geocentric, Earth-Centered,
Earth-Fixed (ECEF) coordinates using Rey-Jer You's transformation for non-prolate ellipsoids.
|
|
|
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 function, integral, 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.
|
|
|
Epsg
EPSG class, a named
int.
|
|
|
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
Pure Python version of Karney's C++ class TransverseMercatorExact, a numerically exact
transverse Mercator projection, abbreviated as
TMExact.
|
|
|
FIx
A named Fractional Index, an int or
float index into a list or
tuple of points, typically.
|
|
|
Fcbrt
Cubic root of a precision summation.
|
|
|
Fcook
Cook's RunningStats computing the
running mean, median and (sample) kurtosis, skewness, variance,
standard deviation and Jarque-Bera normality.
|
|
|
Fdot
Precision dot product.
|
|
|
Feet
Named float representing a distance or length in
feet.
|
|
|
Fhorner
Precision polynomial evaluation using the Horner form.
|
|
|
Fhypot
Precision summation and hypotenuse, default root=2.
|
|
|
Flinear
Cook's RunningRegression computing
the running slope, intercept and correlation of a linear
regression.
|
|
|
Float
Named float.
|
|
|
Float_
Named float with optional low and
high limit.
|
|
|
Footprint5Tuple
5-Tuple (center, upperleft, upperight, loweright,
lowerleft) with the center and 4 corners of the
local projection of a Frustum, each an Xyz4Tuple, XyzLocal, LatLon, etc.
|
|
|
Forward4Tuple
4-Tuple (easting, northing, gamma, scale) in
meter, meter, meridian convergence
gamma at point in degrees and the
scale of projection at point scalar.
|
|
|
Fpolynomial
Precision polynomial evaluation.
|
|
|
Fpowers
Precision summation of powers, optimized for power=2, 3 and
4.
|
|
|
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.
|
|
|
FrechetCosineLaw
Compute the Frechet distance with functionn pygeodesy.cosineLaw.
|
|
|
FrechetDegrees
DEPRECATED, use an other Frechet* class.
|
|
|
FrechetDistanceTo
Compute the Frechet distance with the point1s'
LatLon.distanceTo method.
|
|
|
FrechetEquirectangular
Compute the Frechet distance with function pygeodesy.equirectangular.
|
|
|
FrechetError
Fréchet issue.
|
|
|
FrechetEuclidean
Compute the Frechet distance with function pygeodesy.euclidean.
|
|
|
FrechetExact
Compute the Frechet distance with method GeodesicExact.Inverse.
|
|
|
FrechetFlatLocal
Compute the Frechet distance with function pygeodesy.flatLocal_/pygeodesy.hubeny.
|
|
|
FrechetFlatPolar
Compute the Frechet distance with function flatPolar_.
|
|
|
FrechetHaversine
Compute the Frechet distance with function pygeodesy.haversine_.
|
|
|
FrechetHubeny
Compute the Frechet distance with function pygeodesy.flatLocal_/pygeodesy.hubeny.
|
|
|
FrechetKarney
Compute the Frechet distance with Karney's geographiclib geodesic.Geodesic.Inverse method.
|
|
|
FrechetRadians
DEPRECATED, use an other Frechet* class.
|
|
|
FrechetThomas
Compute the Frechet distance with function pygeodesy.thomas_.
|
|
|
FrechetVincentys
Compute the Frechet distance with function pygeodesy.vincentys_.
|
|
|
Froot
The root of a precision summation.
|
|
|
Frustum
A rectangular pyramid, typically representing a camera's
field-of-view (fov) and the intersection with (or projection
to) a local tangent plane.
|
|
|
Fsqrt
Square root of a precision summation.
|
|
|
Fsum
Precision floating point summation, running summation and
accurate multiplication.
|
|
|
Fsum2Tuple
2-Tuple (fsum, residual) with the precision running
fsum and the residual, the sum of the
remaining partials.
|
|
|
Fwelford
Welford's accumulator computing the running mean,
(sample) variance and standard deviation.
|
|
|
GARSError
Global Area Reference System (GARS) encode, decode or other Garef
issue.
|
|
|
GDict
A dict with both key and
attribute access to the dict items.
|
|
|
Garef
Garef class, a named str.
|
|
|
GeodSolve12Tuple
12-Tuple (lat1, lon1, azi1, lat2, lon2, azi2, s12, a12, m12,
M12, M21, S12) with angles lat1,
lon1, azi1, lat2,
lon2 and azi2 and arc a12
all in degrees, initial azi1 and final
azi2 forward azimuths, distance s12 and
reduced length m12 in meter, area
S12 in meter squared and geodesic
scale factors M12 and M21, both
scalar, see GeodSolve.
|
|
|
Geodesic
Wrapper around Karney's class geographiclib.geodesic.Geodesic.
|
|
|
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 convergence or other issues in geodesicx,
geodesicw or karney.
|
|
|
GeodesicExact
A pure Python version of Karney's C++ class GeodesicExact, modeled after Karney's
Python class geodesic.Geodesic.
|
|
|
GeodesicLine
Wrapper around Karney's class geographiclib.geodesicline.GeodesicLine.
|
|
|
GeodesicLineExact
A pure Python version of Karney's C++ class GeodesicLineExact, modeled after Karney's
Python class geodesicline.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.
|
|
|
Geohash
Geohash class, a named str.
|
|
|
GeohashError
Geohash encode, decode or other Geohash issue.
|
|
|
Geohashed
A cache of en- and decoded geohashes of one precision.
|
|
|
GeoidEGM96
Geoid height interpolator for the EGM96 15 Minute
Interpolation Grid based on SciPy interpolation RectBivariateSpline, interp2d or bisplrep/-ev.
|
|
|
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
interpolation RectBivariateSpline, interp2d or bisplrep/-ev.
|
|
|
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, bisplrep/-ev or interp2d interpolation.
|
|
|
Georef
Georef class, a named str.
|
|
|
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.
|
|
|
HausdorffCosineLaw
Compute the Hausdorff distance with function pygeodesy.cosineLaw_.
|
|
|
HausdorffDegrees
Hausdorff base class for distances from
LatLon points in degrees.
|
|
|
HausdorffDistanceTo
Compute the Hausdorff distance the points'
LatLon.distanceTo method.
|
|
|
HausdorffEquirectangular
Compute the Hausdorff distance with function pygeodesy.equirectangular.
|
|
|
HausdorffError
Hausdorff issue.
|
|
|
HausdorffEuclidean
Compute the Hausdorff distance with function pygeodesy.euclidean_.
|
|
|
HausdorffExact
Compute the Hausdorff distance with method GeodesicExact.Inverse.
|
|
|
HausdorffFlatLocal
Compute the Hausdorff distance with function pygeodesy.flatLocal_/pygeodesy.hubeny_.
|
|
|
HausdorffFlatPolar
Compute the Hausdorff distance with function pygeodesy.flatPolar_.
|
|
|
HausdorffHaversine
Compute the Hausdorff distance with function pygeodesy.haversine_.
|
|
|
HausdorffHubeny
Compute the Hausdorff distance with function pygeodesy.flatLocal_/pygeodesy.hubeny_.
|
|
|
HausdorffKarney
Compute the Hausdorff distance with Karney's geographiclib geodesic.Geodesic.Inverse method.
|
|
|
HausdorffRadians
Hausdorff base class for distances from
LatLon points converted from degrees to
radians.
|
|
|
HausdorffThomas
Compute the Hausdorff distance with function pygeodesy.thomas_.
|
|
|
HausdorffVincentys
Compute the Hausdorff distance with function pygeodesy.vincentys_.
|
|
|
Height
Named float representing a height, conventionally in
meter.
|
|
|
HeightCubic
Height interpolator based on SciPy interp2d kind='cubic' or bisplrep/-ev kx=ky=3.
|
|
|
HeightError
Height interpolator Height... or interpolation issue.
|
|
|
HeightIDWcosineLaw
Height interpolator using Inverse Distance Weighting (IDW) and function pygeodesy.cosineLaw.
|
|
|
HeightIDWdistanceTo
Height interpolator using Inverse Distance Weighting (IDW) and the points'
LatLon.distanceTo method.
|
|
|
HeightIDWequirectangular
Height interpolator using Inverse Distance Weighting (IDW) and function pygeodesy.equirectangular4.
|
|
|
HeightIDWeuclidean
Height interpolator using Inverse Distance Weighting (IDW) and function pygeodesy.euclidean_.
|
|
|
HeightIDWexact
Height interpolator using Inverse Distance Weighting (IDW) and method GeodesicExact.Inverse.
|
|
|
HeightIDWflatLocal
Height interpolator using Inverse Distance Weighting (IDW) and the function
pygeodesy.flatLocal_/pygeodesy.hubeny_.
|
|
|
HeightIDWflatPolar
Height interpolator using Inverse Distance Weighting (IDW) and function pygeodesy.flatPolar_.
|
|
|
HeightIDWhaversine
Height interpolator using Inverse Distance Weighting (IDW) and function pygeodesy.haversine_.
|
|
|
HeightIDWhubeny
Height interpolator using Inverse Distance Weighting (IDW) and the function
pygeodesy.flatLocal_/pygeodesy.hubeny_.
|
|
|
HeightIDWkarney
Height interpolator using Inverse Distance Weighting (IDW) and
Karney's geographiclib method geodesic.Geodesic.Inverse.
|
|
|
HeightIDWthomas
Height interpolator using Inverse Distance Weighting (IDW) and function pygeodesy.thomas_.
|
|
|
HeightIDWvincentys
Height interpolator using Inverse Distance Weighting (IDW) and function pygeodesy.vincentys_.
|
|
|
HeightLSQBiSpline
Height interpolator using SciPy LSQSphereBivariateSpline.
|
|
|
HeightLinear
Height interpolator based on SciPy interp2d kind='linear' or bisplrep/-ev kx=ky=1.
|
|
|
HeightSmoothBiSpline
Height interpolator using SciPy SmoothSphereBivariateSpline.
|
|
|
HeightX
Like Height, used to distinguish the interpolated
height from an original Height at a clip intersection.
|
|
|
Height_
Named float with optional low and
high limits representing a height, conventionally in
meter.
|
|
|
Helmert7Tuple
DEPRECATED on 2024.02.02, use class TRFXform7Tuple, without keyword arguments.
|
|
|
Int
Named int.
|
|
|
Int_
Named int with optional limits low and
high.
|
|
|
Intersect7Tuple
7-Tuple (A, B, sAB, aAB, c, kA, kB) with
A and B each a LatLon or LatLon4Tuple(lat, lon, height, datum)
of the intersection on each geodesic line, the distance
sAB in in meter and angular distance
aAB in degrees between A and
B, coincidence indicator c and segment
indicators kA and kB all
int, see XDict
and method intersect7.
|
|
|
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 line or circle intersection issues.
|
|
|
Intersectool
Wrapper to invoke Karney's utility IntersectTool similar to class Intersector.
|
|
|
Intersectool5Tuple
5-Tuple (A, B, sAB, aAB, c) with A and
B the Position of the intersection on
each geodesic line, the distance sAB between
A and B in meter, the
angular distance aAB in degrees and
coincidence indicator c (int), see XDict.
|
|
|
Intersector
Finder of intersections between two goedesic lines, each an
instance of GeodesicLineExact, wrapped GeodesicLine or GeodesicLineSolve.
|
|
|
Intersector5Tuple
5-Tuple (A, B, sAB, aAB, c) with A and
B the Position of the intersection on
each geodesic line, the distance sAB between
A and B in meter, angular
distance aAB in degrees and coincidence
indicator c (int), see XDict.
|
|
|
Inverse10Tuple
10-Tuple (a12, s12, salp1, calp1, salp2, calp2, m12, M12,
M21, S12) with arc length a12 in
degrees, distance s12 and reduced length
m12 in meter, area S12 in
meter squared and the sines salp1,
salp2 and cosines calp1,
calp2 of the initial 1 and final
2 (forward) azimuths.
|
|
|
Jacobi2Tuple
2-Tuple (x, y) with a Jacobi Conformal x
and y projection, both in Radians
(or Degrees).
|
|
|
JacobiConformal
This is a conformal projection of a triaxial ellipsoid to a plane
in which the X and Y grid lines are
straight.
|
|
|
JacobiConformalSpherical
An alternate, spherical JacobiConformal projection.
|
|
|
KTMError
Error raised for KTransverseMercator and KTransverseMercator.forward issues.
|
|
|
KTransverseMercator
Karney's C++ class TransverseMercator transcoded to pure Python,
following is a partial copy of Karney's documentation.
|
|
|
LCCError
Lambert Conformal Conic LCC or other Lcc issue.
|
|
|
Lam
Named float representing a longitude in
radians.
|
|
|
Lam_
DEPRECATED on 2024.06.15, use class Lamd.
|
|
|
LambertEqualArea
Lambert-equal-area projection for the sphere*** (aka Lambert zenithal equal-area projection, see Snyder, pp 185-187 and MathWorld-Wolfram.
|
|
|
Lamd
Named float representing a longitude in
radians converted from degrees.
|
|
|
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, gamma, scale) in
degrees90, degrees180, Datum,
degrees and float.
|
|
|
LatLonExact4Tuple
DEPRECATED, use class Reverse4Tuple, item gamma for
convergence.
|
|
|
LatLonFHP
A point or intersection in a BooleanFHP clip or composite.
|
|
|
LatLonGH
A point or intersection in a BooleanGH clip or composite.
|
|
|
LatLonHeightBase
'DEPRECATED on 2021.02.10, use (INTERNAL) class pygeodesy.latlonBase.LatLonBase.
|
|
|
LatLonNvectorBase
(INTERNAL) Base class for n-vector-based ellipsoidal and spherical
LatLons.
|
|
|
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, mainly for Numpy2LatLon and Tuple2LatLon.
|
|
|
Lat_
Named float representing a latitude in
degrees within limits low and
high.
|
|
|
LazyAttributeError
Raised if a lazily imported attribute is missing or
invalid.
|
|
|
LazyImportError
Raised if lazy import is not supported, disabled or
failed some other way.
|
|
|
Lcc
Lambert conformal conic East-/Northing location.
|
|
|
LenError
Error raised for mis-matching len values.
|
|
|
LimitError
Error raised for lat- or longitudinal values or deltas exceeding
the given limit in functions equirectangular, equirectangular4, nearestOn* and
simplify* or methods with limit or
options keyword arguments.
|
|
|
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.
|
|
|
Los
A Line-Of-Sight (LOS) from a LatLon or
Cartesian location.
|
|
|
Ltp
A local tangent plan (LTP), a sub-class of
LocalCartesian with (re-)configurable ECEF converter.
|
|
|
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, EN, easting, northing),
zone and grid tile EN as
str, easting and northing in
meter.
|
|
|
Mgrs6Tuple
6-Tuple (zone, EN, easting, northing, band, datum),
with zone, grid tile EN and
band as str, easting and
northing in meter and datum
a Datum.
|
|
|
Middle5Tuple
5-Tuple (A, B, sMM, aMM, c) with A and
B the line segments including the mid-point
location in latM, lonM, distance
s1M in meter and angular distance
a1M in degrees, the distance between both
mid-points sMM in meter and angular
distance aMM in degrees and coincidence
indicator c (int).
|
|
|
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.
|
|
|
NearestOn4Tuple
DEPRECATED on 2023.10.10, see methods RhumbLine.nearestOn4 and RhumbLineAux.nearestOn4.
|
|
|
NearestOn6Tuple
6-Tuple (closest, distance, fi, j, start, end) with
the closest point, the distance in
meter, conventionally and the start and
end point of the path or polygon edge.
|
|
|
NearestOn8Tuple
8-Tuple (closest, distance, fi, j, start, end, initial,
final), like NearestOn6Tuple but extended with the
initial and the final bearing at the
reference respectively the closest point, both in
compass degrees.
|
|
|
Ned
Local North-Eeast-Down (NED) location in a local
tangent plane.
|
|
|
Ned3Tuple
DEPRECATED, use class Ned4Tuple, ignoring item ltp.
|
|
|
Ned4Tuple
4-Tuple (north, east, down, ltp), all in
meter except ltp.
|
|
|
Neighbors8Dict
8-Dict (N, NE, E, SE, S, SW, W, NW) of Geohashes, providing key and attribute
access to the items.
|
|
|
Northing
Named float representing a northing, conventionally in
meter.
|
|
|
NumPyError
Error raised for NumPy issues.
|
|
|
Number_
Named int representing a non-negative number.
|
|
|
Numpy2LatLon
Wrapper for NumPy arrays as "on-the-fly"
LatLon points.
|
|
|
Nvector
DEPRECATED on 2021.05.20, see (INTERNAL) class pygeodesy.nvectorBase.NvectorBase.
|
|
|
OSGRError
Error raised for a parseOSGR, Osgr or
other OSGR issue.
|
|
|
Orthographic
Orthographic projection for the sphere***, see Snyder, pp 148-153 and MathWorld-Wolfram.
|
|
|
Osgr
Ordnance Survey Grid References (OSGR) coordinates on the National Grid.
|
|
|
PGMError
An issue while 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_
DEPRECATED on 2024.06.15, use class Phid.
|
|
|
Phid
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, 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.
|
|
|
RadiusThetaPhi3Tuple
3-Tuple (r, theta, phi) with radial distance
r in meter, inclination
theta (with respect to the positive z-axis) and
azimuthal angle phi in Degrees
or Radians representing a spherical, polar position.
|
|
|
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 in functions parse3llh, parseDMS, parseDMS2 and parseRad
or the limit set with functions clipDegrees and clipRadians.
|
|
|
RefFrame
Terrestrial Reference Frame (TRF) parameters.
|
|
|
ResectionError
Error raised for issues in pygeodesy.resections.
|
|
|
ResidualError
Error raised for a division, power or root operation of an Fsum
instance with a residual ratio exceeding the RESIDUAL threshold.
|
|
|
Resolutions2Tuple
2-Tuple (res1, res2) with the primary
(longitudinal) and secondary (latitudinal)
resolution, both in degrees.
|
|
|
Reverse4Tuple
4-Tuple (lat, lon, gamma, scale) with
lat- and longitude in
degrees, meridian convergence gamma at
point in degrees and the scale of
projection at point scalar.
|
|
|
Rhumb
Class to solve the direct and inverse rhumb problems,
based on elliptic functions or Krüger series
expansion
|
|
|
Rhumb7Tuple
DEPRECATED, use class Rhumb8Tuple, ignoring item a12.
|
|
|
Rhumb8Tuple
8-Tuple (lat1, lon1, lat2, lon2, azi12, s12, S12, a12)
with lat- lat1, lat2 and longitudes
lon1, lon2 of both points, the azimuth of
the rhumb line azi12, the distance s12,
the area S12 under the rhumb line and the angular
distance a12 between both points.
|
|
|
RhumbAux
Class to solve the direct and inverse rhumb problems,
based on Auxiliary Latitudes for accuracy near the poles.
|
|
|
RhumbError
Error raised for a rhumb aux_, ekx or solve issue.
|
|
|
RhumbLine
Compute one or several points on a single rhumb line.
|
|
|
RhumbLineAux
Compute one or several points on a single rhumb line.
|
|
|
RhumbLineSolve
Wrapper to invoke Karney's RhumbSolve like a class, similar to pygeodesy.RhumbLine and pygeodesy.RhumbLineAux.
|
|
|
RhumbOrder2Tuple
DEPRECATED, see deprecated method Rhumb.orders.
|
|
|
RhumbSolve
Wrapper to invoke Karney's RhumbSolve like a class, similar to pygeodesy.Rhumb and pygeodesy.RhumbAux.
|
|
|
RhumbSolve7Tuple
7-Tuple (lat1, lon1, lat2, lon2, azi12, s12, S12) with
lat- lat1, lat2 and longitudes
lon1, lon2 of both points, the azimuth of
the rhumb line azi12, the distance s12
and the area S12 under the rhumb line between both
points.
|
|
|
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 issues.
|
|
|
SciPyWarning
Error thrown for SciPy warnings.
|
|
|
Shape2Tuple
2-Tuple (nrows, ncols), the number of rows and
columns, both int.
|
|
|
Sizes3Tuple
3-Tuple (height, width, radius) with latitudinal
height, longitudinal width and area
radius, all in meter.
|
|
|
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, callable str.
|
|
|
Str_
Extended, callable str class, not nameable.
|
|
|
Survey3Tuple
3-Tuple (PA, PB, PC) with distance from survey point
P to each of the triangle corners A,
B and C in meter,
conventionally.
|
|
|
TRFError
Terrestrial Reference Frame (TRF), Epoch, RefFrame
or RefFrame conversion issue.
|
|
|
TRFXform
A Terrestrial Reference Frame (TRF) converter between two reference
frames observed at an epoch.
|
|
|
TRFXform7Tuple
7-Tuple (tx, ty, tz, s, sx, sy, sz) of conversion
parameters with translations tx, ty and
tz in milli-meter, scale s
in ppB and rotations sx, sy
and sz in milli-arc-seconds.
|
|
|
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 datum transformation.
|
|
|
Transform7Tuple
DEPRECATED on 2024.02.02, use class TRFXform7Tuple, without keyword arguments.
|
|
|
TransformXform
Helmert transformation, extended with an Xform TRF
converter.
|
|
|
TriAngle4Tuple
DEPRECATED on 2023.09.14, use class TriAngle5Tuple, ignoring item area.
|
|
|
TriAngle5Tuple
5-Tuple (radA, radB, radC, rIn, area) with the
interior angles at triangle corners A, B
and C in radians, the
InCircle radius rIn aka
inradius in meter and the triangle
area in meter squared,
conventionally.
|
|
|
TriSide2Tuple
2-Tuple (a, radA) with triangle side a in
meter, conventionally and angle radA at
the opposite triangle corner in radians.
|
|
|
TriSide4Tuple
4-Tuple (a, b, radC, d) with interior angle
radC at triangle corner C in
radianswith the length of triangle sides
a and b and with triangle height
d perpendicular to triangle side c, in
the same units as triangle sides a and b.
|
|
|
Triangle7Tuple
7-Tuple (A, a, B, b, C, c, area) with interior angles
A, B and C in
degrees, spherical sides a,
b and c in meter
conventionally and the area of a (spherical) triangle
in square meter conventionally.
|
|
|
Triangle8Tuple
8-Tuple (A, a, B, b, C, c, D, E) with interior angles
A, B and C, spherical sides
a, b and c, the spherical
deficit D and the spherical excess
E of a (spherical) triangle, all in
radians.
|
|
|
TriangleError
Error raised for triangle, intersection or resection issues.
|
|
|
Triaxial
Ordered triaxial ellipsoid.
|
|
|
TriaxialError
Raised for Triaxial issues.
|
|
|
Triaxial_
Unordered triaxial ellipsoid and base class.
|
|
|
Triaxum5Tuple
5-Tuple (a, b, c, rank, residuals) with the
(unordered) triaxial radii a, b and
c of an ellipsoid least-squares fitted through
given points and the rank and residuals
-if any- from numpy.linalg.lstsq.
|
|
|
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 for a value exceeding the
low or high limit.
|
|
|
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
DEPRECATED and OBSOLETE, expect a UtmUps5Tuple from method
pygeodesy.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,
gamma, 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.
|
|
|
Uvw
3-D u-v-w (UVW) components.
|
|
|
Uvw3Tuple
3-Tuple (u, v, w), in meter.
|
|
|
Vector2Tuple
2-Tuple (x, y) of (geocentric) components, each in
meter or the same units.
|
|
|
Vector3Tuple
3-Tuple (x, y, z) of (geocentric) components, all in
meter or the same units.
|
|
|
Vector3d
Extended 3-D vector.
|
|
|
Vector4Tuple
4-Tuple (x, y, z, h) of (geocentric) components, all
in meter or the same units.
|
|
|
VectorError
Vector3d, Cartesian* or
*Nvector issues.
|
|
|
VincentyError
Error raised by Vincenty's Direct and
Inverse methods for coincident points or lack of
convergence.
|
|
|
WGRSError
World Geographic Reference System (WGRS) encode, decode or other Georef
issue.
|
|
|
WebMercatorError
Web Mercator (WM) parser or Wm
issue.
|
|
|
Wm
Web Mercator (WM) coordinate.
|
|
|
XDict
4+Item result from Intersectool and Intersector methods All,
Closest, Next and Segment
with the intersection offsets sA, sB and
sX0 in meter and the coincidence
indicator c, an int, +1 for parallel, -1
for anti-parallel or 0 otherwise.
|
|
|
XDist
DEPRECATED on 2024.07.02, use class XDict.
|
|
|
Xyz4Tuple
4-Tuple (x, y, z, ltp), all in meter
except ltp.
|
|
|
XyzLocal
Local (x, y, z) in a local tangent plane (LTP),
also base class for local Enu.
|
|
|
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
|
|
|
property_ROnce
|
|
|
property_ROver
|
|
|
|
|
|
Fn_rt(root,
*xs,
**name_RESIDUAL_raiser)
DEPRECATED on 2024.04.17, use class Froot. |
|
|
|
|
FrechetCosineAndoyerLambert(point1s,
**kwds)
DEPRECATED on 2024.12.31, use class FrechetCosineLaw with corr=1. |
|
|
|
|
FrechetCosineForsytheAndoyerLambert(point1s,
**kwds)
DEPRECATED on 2024.12.31, use class FrechetCosineLaw with corr=2. |
|
|
|
|
Fsum2product(*xs,
**kwds)
DEPRECATED on 2024.09.19, use Fsum(*xs, f2product=True,
...). |
|
|
|
|
Geodesic_WGS84()
Get the wrapped Geodesic(WGS84) singleton, provided geographiclib is installed, otherwise an
ImportError. |
|
|
|
|
HausdorffCosineAndoyerLambert(point1s,
**kwds)
DEPRECATED on 2024.12.31, use class HausdorffCosineLaw with corr=1. |
|
|
|
|
HausdorffCosineForsytheAndoyerLambert(point1s,
**kwds)
DEPRECATED on 2024.12.31, use class HausdorffCosineLaw with corr=2. |
|
|
|
|
|
|
|
|
|
|
|
|
|
HeightIDWcosineAndoyerLambert(knots,
**kwds)
DEPRECATED on 2024.12.31, use class HeightIDWcosineLaw with corr=1. |
|
|
|
|
HeightIDWcosineForsytheAndoyerLambert(knots,
**kwds)
DEPRECATED on 2024.12.31, use class HeightIDWcosineLaw with corr=2. |
|
|
|
|
NM2m(nm)
Convert nautical miles to meter (m). |
|
|
|
|
RefFrameError(*args,
**kwds)
DEPRECATED, use class TRFError. |
|
|
|
|
SM2m(sm)
Convert statute miles to meter (m). |
|
|
|
|
SinCos2(x)
Get sin and cos of typed angle. |
|
|
|
|
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. |
|
|
|
|
|
|
|
angle2chord(rad,
radius=6371008.771415)
Get the chord length of a (central) angle or angular distance. |
|
|
|
|
anstr(name,
OKd='._-',
sub='_')
Make a valid name of alphanumeric and OKd characters. |
|
|
|
|
antipode(lat,
lon,
**name)
Return the antipode, the point diametrically opposite to a given
point in degrees. |
|
|
|
|
antipode_(phi,
lam,
**name)
Return the antipode, the point diametrically opposite to a given
point in radians. |
|
|
|
|
areaOf(points,
adjust=True,
radius=6371008.771415,
wrap=True)
Approximate the area of a polygon or composite. |
|
|
|
|
|
|
|
asin1(x)
Return math.asin(max(-1, min(1, x))). |
|
|
|
|
atan1(y,
x=1.0)
Return atan(y / x) angle in
radians [-PI/2..+PI/2] using
atan2 for consistency and to avoid
ZeroDivisionError. |
|
|
|
|
atan1d(y,
x=1.0)
Return atan(y / x) angle in
degrees [-90..+90] using
atan2d for consistency and to avoid
ZeroDivisionError. |
|
|
|
|
atan2(y,
x)
Return the arc tangent (measured in radians) of y/x. |
|
|
|
|
atan2b(y,
x)
Return atan2(y, x) in degrees [0..+360], counter-clockwise. |
|
|
|
|
atan2d(y,
x,
reverse=False)
Return atan2(y, x) in degrees [-180..+180], optionally reversed (by 180
degrees for azimuths). |
|
|
|
|
|
|
|
attrs(inst,
*names,
**Nones_True__pairs_kwds)
Get instance attributes as name=value strings, with
floats formatted by function fstr. |
|
|
|
|
b_f2a(b,
f)
Return a, the equatorial radius for a given
polar radius and flattening. |
|
|
|
|
b_f_2a(b,
f_)
Return a, the equatorial radius for a given
polar radius and inverse flattening. |
|
|
|
|
bearing(lat1,
lon1,
lat2,
lon2,
**final_wrap)
Compute the initial or final bearing (forward or reverse azimuth)
between two (spherical) points. |
|
|
|
|
bearingDMS(bearing,
form='d',
prec=None,
sep='',
**s_D_M_S)
Convert bearing to a string (without compass point suffix). |
|
|
|
|
bearing_(phi1,
lam1,
phi2,
lam2,
final=False,
wrap=False)
Compute the initial or final bearing (forward or reverse azimuth)
between two (spherical) points. |
|
|
|
|
bounds(geohash,
LatLon=None,
**LatLon_kwds)
Returns the lower-left SW and upper-right NE corners of a geohash. |
|
|
|
|
boundsOf(points,
wrap=False,
LatLon=None)
Determine the bottom-left SW and top-right NE corners of a path or
polygon. |
|
|
|
|
bqrt(x)
Return the 4-th, bi-quadratic or quartic root, x**(1 / 4), preserving type(x). |
|
|
|
|
callername(up=1,
dflt='',
source=False,
underOK=False)
Get the name of the invoking callable. |
|
|
|
|
cassini(pointA,
pointB,
pointC,
alpha,
beta,
useZ=False,
**Clas_and_kwds)
3-Point resection using Cassini's method. |
|
|
|
|
cbrt(x)
Compute the cube root x**(1/3), preserving
type(x). |
|
|
|
|
cbrt2(x)
Compute the cube root squared x**(2/3),
preserving type(x). |
|
|
|
|
centroidOf(points,
wrap=False,
LatLon=None)
Determine the centroid of a polygon. |
|
|
|
|
chain2m(chains)
Convert UK chains to meter. |
|
|
|
|
chord2angle(chord,
radius=6371008.771415)
Get the (central) angle from a chord length or distance. |
|
|
|
|
circin6(point1,
point2,
point3,
eps=8.881784197001252e-16,
useZ=True)
Return the radius and center of the inscribed aka
Incircle 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.881784197001252e-16,
useZ=True)
Return the radius and center of the smallest circle through or
containing three (2- or 3-D) points. |
|
|
|
|
circum4(points,
useZ=True,
**Vector_and_kwds)
Best-fit a sphere through three or more (3-D) points. |
|
|
|
|
circum4_(*points,
**useZ_Vector_and_kwds)
Best-fit a sphere through three or more (3-D) positional 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,
upperight,
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. |
|
|
|
|
clipFHP4(points,
corners,
closed=False,
inull=False,
raiser=False,
eps=2.220446049250313e-16)
Clip one or more polygons against a clip region or box using Forster-Hormann-Popa's C++ implementation
transcoded to pure Python. |
|
|
|
|
clipGH4(points,
corners,
closed=False,
inull=False,
raiser=True,
xtend=False,
eps=2.220446049250313e-16)
Clip one or more polygons against a clip region or box using the Greiner-Hormann algorithm, Correia's implementation modified and extended. |
|
|
|
|
clipLB6(points,
lowerleft,
upperight,
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(sb,
limit=50,
white='',
length=False)
Clip a string to the given length limit. |
|
|
|
|
|
|
|
collins5(pointA,
pointB,
pointC,
alpha,
beta,
useZ=False,
**Clas_and_kwds)
3-Point resection using Collins' method. |
|
|
|
|
compassAngle(lat1,
lon1,
lat2,
lon2,
adjust=True,
wrap=False)
Return the angle from North for the direction vector (lon2 - lon1, lat2 - lat1) between two points. |
|
|
|
|
compassDMS(bearing,
form='d',
prec=None,
sep='',
**s_D_M_S)
Convert bearing to a string suffixed with compass point. |
|
|
|
|
compassPoint(bearing,
prec=3)
Convert a bearing from North 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. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cosineLaw(lat1,
lon1,
lat2,
lon2,
corr=0,
earth=None,
wrap=False,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...,
radius=6371008.771415)
Compute the distance between two points using the Law of Cosines formula, optionally corrected. |
|
|
|
|
cosineLaw_(phi2,
phi1,
lam21,
corr=0,
earth=None,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...)
Compute the angular distance between two points using the Law of Cosines formula, optionally corrected. |
|
|
|
|
cot(rad,
**raiser_kwds)
Return the cotangent of an angle in
radians. |
|
|
|
|
cot_(*rads,
**raiser_kwds)
Yield the cotangent of angle(s) in radians. |
|
|
|
|
cotd(deg,
**raiser_kwds)
Return the cotangent of an angle in
degrees. |
|
|
|
|
cotd_(*degs,
**raiser_kwds)
Yield the cotangent of angle(s) in degrees. |
|
|
|
|
crosserrors(raiser=None)
Report or ignore vectorial cross product errors. |
|
|
|
|
date2epoch(year,
month,
day)
Return the 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.771415,
lat=0)
Convert an angle to a distance along the equator or along a parallel
at (geodetic) latitude. |
|
|
|
|
degrees360(rad)
Convert radians to degrees and wrap [0..+360). |
|
|
|
|
degrees90(rad)
Convert radians to degrees and wrap [-90..+90). |
|
|
|
|
|
|
|
deprecated_class(cls_or_class)
Use inside __new__ or __init__ of a DEPRECATED class. |
|
|
|
|
|
|
|
|
|
|
|
|
|
e22f(e2)
Return f, the flattening for a given 1st
eccentricity squared. |
|
|
|
|
e2f(e)
Return f, the flattening for a given 1st
eccentricity. |
|
|
|
|
|
|
|
elevation2(lat,
lon,
timeout=2.0)
Get the geoid elevation at an NAD83 to
NAVD88 location. |
|
|
|
|
|
|
|
|
|
|
enstr2(easting,
northing,
prec,
*extras,
**wide_dot)
Return an MGRS/OSGR easting, northing string representations. |
|
|
|
|
epoch2date(epoch)
Return the date for a reference frame epoch. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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.771415,
adjust=True,
wrap=False)
Approximate the Euclidean distance between two
(spherical) points. |
|
|
|
|
|
|
|
|
|
|
|
|
|
excessAbc_(A,
b,
c)
Compute the spherical excess E of a (spherical)
triangle from two sides and the included (small) angle. |
|
|
|
|
|
|
|
|
|
|
|
|
|
excessKarney(lat1,
lon1,
lat2,
lon2,
radius=6371008.771415,
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.771415,
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. |
|
|
|
|
f2mul_(x,
*ys,
**nonfinites)
Cascaded, accurate multiplication x * y *
y ... for all ys. |
|
|
|
|
f2n(f)
Return n, the 3rd flattening for a given
flattening. |
|
|
|
|
f2product(two=None)
Turn accurate TwoProduct multiplication on or off. |
|
|
|
|
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 class Easting or Northing. |
|
|
|
|
falsed2f(falsed=True,
Error=<type 'exceptions.ValueError'>,
**name_value)
DEPRECATED, use class Easting or Northing. |
|
|
|
|
|
|
|
fatan(x)
Fast approximation of atan(x), scalar. |
|
|
|
|
fatan1(x)
Fast approximation of atan(x) for 0 <=
x < 1, unchecked. |
|
|
|
|
fatan2(y,
x)
Fast approximation of atan2(y, x), scalar. |
|
|
|
|
fathom2m(fathoms)
Convert Imperial fathom to meter. |
|
|
|
|
favg(a,
b,
f=0.5,
nonfinites=True)
Return the precise average of two values. |
|
|
|
|
fdot(xs,
*ys,
**start_f2product_nonfinites)
Return the precision dot product sum(xs[i] * ys[i]
for i in range(len(xs))). |
|
|
|
|
fdot3(xs,
ys,
zs,
**start_f2product_nonfinites)
Return the (precision) dot product start + sum(xs[i]
* ys[i] * zs[i] for i in range(len(xs))). |
|
|
|
|
fdot_(*xys,
**start_f2product_nonfinites)
Return the (precision) dot product sum(xys[i] *
xys[i+1] for i in range(0, len(xys), 2)). |
|
|
|
|
fhorner(x,
*cs,
**incx)
Horner form evaluation of polynomial sum(cs[i] * x**i
for i=0..n) as in- or decreasing exponent sum(...
i=n..0), where n = len(cs) - 1. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
float0_(*xs)
Yield xs as a non-NEG0 float. |
|
|
|
|
float_(*fs,
**sets)
Get scalars as float or intern'ed
float. |
|
|
|
|
fma(x,
y,
z,
**nonfinites)
Fused-multiply-add, using math.fma(x, y, z) in Python
3.13+ or an equivalent implementation. |
|
|
|
|
fmean(xs)
Compute the accurate mean sum(xs) / len(xs). |
|
|
|
|
fmean_(*xs,
**nonfinites)
Compute the accurate mean sum(xs) / len(xs). |
|
|
|
|
fpolynomial(x,
*cs,
**over_f2product_nonfinites)
Evaluate the polynomial sum(cs[i] * x**i for
i=0..len(cs)) [/ over]. |
|
|
|
|
fpowers(x,
n,
alts=0)
Return a series of powers [x**i for i=1..n], note
1..! |
|
|
|
|
fprod(xs,
start=1)
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. |
|
|
|
|
frandoms(n,
seeded=None)
Generate n (long) lists of random floats. |
|
|
|
|
frange(start,
number,
step=1)
Generate a range of floats. |
|
|
|
|
frechet_(point1s,
point2s,
distance=None,
units='')
Compute the discrete Fréchet distance between two paths, each given as a
set of points. |
|
|
|
value
|
freduce(function,
sequence,
initial=...)
Apply a function of two arguments cumulatively to the items of a
sequence, from left to right, so as to reduce the sequence to a
single value. |
|
|
|
|
fremainder(x,
y)
Remainder in range [-y / 2, y / 2]. |
|
|
|
|
fstr(floats,
prec=6,
fmt='F',
ints=False,
sep=', ',
strepr=None,
force=True)
Convert one or more floats to string, optionally stripped of trailing
zero decimals. |
|
|
|
|
fstrzs(efstr,
ap1z=False)
Strip trailing zero decimals from a float string. |
|
|
|
|
fsum(xs,
nonfinites=None,
**floats)
Precision floating point summation from Python's
math.fsum. |
|
|
|
|
fsum1(xs,
**nonfinites)
Precision floating point summation, 1-primed. |
|
|
|
|
fsum1_(*xs,
**nonfinites)
Precision floating point summation of all positional items, 1-primed. |
|
|
|
|
fsum1f_(*xs)
Precision floating point summation of all positional items, 1-primed
and with non-finites OK. |
|
|
|
|
fsum_(*xs,
**nonfinites)
Precision floating point summation of all positional items. |
|
|
|
|
fsumf_(*xs)
Precision floating point summation of all positional items with
non-finites OK. |
|
|
|
|
ft2m(feet,
usurvey=False,
pied=False,
fuss=False)
Convert International, US Survey, French or
German 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). |
|
|
|
|
ha2acre(ha)
Convert hectare to acre. |
|
|
|
|
ha2m2(ha)
Convert hectare to square meter. |
|
|
|
|
halfs2(str2)
Split a string in 2 halfs. |
|
|
|
|
hartzell(pov,
los=False,
earth=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...,
**name_LatLon_and_kwds)
Compute the intersection of the earth's surface and a Line-Of-Sight
from a Point-Of-View in space. |
|
|
|
|
hartzell4(pov,
los=False,
tri_biax=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...,
**name)
Compute the intersection of a tri-/biaxial ellipsoid and a
Line-Of-Sight from a Point-Of-View outside. |
|
|
|
|
hausdorff_(model,
target,
both=False,
early=True,
seed=None,
units='',
distance=None,
point=<function _point at 0x7f7af8a96e50>)
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.771415,
wrap=False)
Compute the distance between two (spherical) points using the Haversine formula. |
|
|
|
|
|
|
|
heightOf(angle,
distance,
radius=6371008.771415)
Determine the height above the (spherical) earth' surface after
traveling along a straight line at a given tilt. |
|
|
|
|
heightOrthometric(h_loc,
N)
Get the orthometric height H, the height above the
geoid, earth surface. |
|
|
|
|
horizon(height,
radius=6371008.771415,
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...,
scaled=True,
wrap=False)
Compute the distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula. |
|
|
|
|
|
|
|
hypot(x,
y)
Return the Euclidean distance, sqrt(x*x + y*y). |
|
|
|
|
hypot1(x)
Compute the norm sqrt(1 + x**2). |
|
|
|
|
hypot2(x,
y)
Compute the squared norm x**2 + y**2. |
|
|
|
|
hypot2_(*xs)
Compute the squared norm fsum(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. |
|
|
|
|
int1s(x)
Count the number of 1-bits in an int, unsigned. |
|
|
|
|
intersection2(lat1,
lon1,
bearing1,
lat2,
lon2,
bearing2,
datum=None,
wrap=False,
small=100000.0)
Conveniently compute the intersection of two lines each
defined by a (geodetic) point and a bearing from North, using either
... |
|
|
|
|
intersection3d3(start1,
end1,
start2,
end2,
eps=2.220446049250313e-16,
useZ=True,
**Vector_and_kwds)
Compute the intersection point of two (2- or 3-D) lines, each defined
by two points or by a point and a bearing. |
|
|
|
|
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. |
|
|
|
|
|
|
|
isCartesian(obj,
ellipsoidal=None)
Is object some Cartesian? |
|
|
|
|
isDEPRECATED(obj)
Is object a DEPRECATED class, method
or function? |
|
|
|
|
isError(exc)
Check a (caught) exception. |
|
|
|
|
isLatLon(obj,
ellipsoidal=None)
Is object some LatLon? |
|
|
|
|
isNumpy2(obj)
Check for a Numpy2LatLon points wrapper. |
|
|
|
|
isNvector(obj,
ellipsoidal=None)
Is object some Nvector? |
|
|
|
|
isPoints2(obj)
Check for a LatLon2psxy points wrapper. |
|
|
|
|
isTuple2(obj)
Check for a Tuple2LatLon points wrapper. |
|
|
|
|
isantipode(lat1,
lon1,
lat2,
lon2,
eps=2.220446049250313e-16)
Check whether two points are antipodal, on diametrically
opposite sides of the earth. |
|
|
|
|
isantipode_(phi1,
lam1,
phi2,
lam2,
eps=2.220446049250313e-16)
Check whether two points are antipodal, on diametrically
opposite sides of the earth. |
|
|
|
|
isbool(obj)
Is object a boolean? |
|
|
|
|
isclass(obj)
Is object a Class or
type? |
|
|
|
|
isclockwise(points,
adjust=False,
wrap=True)
Determine the direction of a path or polygon. |
|
|
|
|
isclose(a,
b,
rel_tol=1e-12,
abs_tol=4.930380657631324e-32)
Like math.isclose, but with defaults such that
isclose(0, EPS0) is True by default. |
|
|
|
|
iscolinearWith(point,
point1,
point2,
eps=2.220446049250313e-16,
useZ=True)
Check whether a point is colinear with two other (2- or 3-D) points. |
|
|
|
|
iscomplex(obj,
both=False)
Is object a complex or complex
literal str? |
|
|
|
|
isconvex(points,
adjust=False,
wrap=False)
Determine whether a polygon is convex. |
|
|
|
|
isconvex_(points,
adjust=False,
wrap=False)
Determine whether a polygon is convex and clockwise. |
|
|
|
|
isenclosedBy(point,
points,
wrap=False)
Determine whether a point is enclosed by a polygon or composite. |
|
|
|
|
|
|
|
isfinite(obj)
Check a finite scalar, complex, ... |
|
|
|
|
isfloat(obj,
both=False)
Is object a float or float literal
str? |
|
|
|
|
isidentifier(obj)
Is object a Python identifier? |
|
|
|
bool
|
isinf(x)
Check if float x is infinite (positive or negative). |
|
|
|
|
isinstanceof(obj,
*Classes)
Is object an instance of one of the
Classes? |
|
|
|
|
isint(obj,
both=False)
Is object an int or integer
float value? |
|
|
|
|
isint0(obj,
both=False)
Check for INT0 or int(0) value. |
|
|
|
|
|
|
|
isiterablen(obj,
strict=False)
Is object iterable and has
length? |
|
|
|
|
isiterabletype(obj,
method='__iter__')
Is object an instance of an iterable
class or type? |
|
|
|
|
|
|
|
islistuple(obj,
minum=0)
Is object a list or
tuple with non-zero length? |
|
|
|
bool
|
isnan(x)
Check if float x is not a number (NaN). |
|
|
|
|
isnear0(x,
eps0=4.930380657631324e-32)
Is x near zero within a tolerance? |
|
|
|
|
isnear1(x,
eps1=4.930380657631324e-32)
Is x near one within a tolerance? |
|
|
|
|
isnear90(x,
eps90=4.930380657631324e-32)
Is x near 90 within a tolerance? |
|
|
|
|
|
|
|
|
|
|
isnon0(x,
eps0=4.930380657631324e-32)
Is x non-zero with a tolerance? |
|
|
|
|
isnormal(lat,
lon,
eps=0)
Check whether lat and
lon are within their respective normal
range in degrees. |
|
|
|
|
isnormal_(phi,
lam,
eps=0)
Check whether phi and
lam are within their respective normal
range in radians. |
|
|
|
|
|
|
|
ispolar(points,
wrap=False)
Check whether a polygon encloses a pole. |
|
|
|
|
isscalar(obj,
both=False)
Is object an int or integer
float value? |
|
|
|
|
issequence(obj,
*excls)
Is object some sequence type? |
|
|
|
|
isstr(obj)
Is object some string type? |
|
|
|
|
issubclassof(Sub,
*Supers)
Is Sub a class and sub-class of some other
class(es)? |
|
|
|
|
|
|
|
itemsorted(adict,
*items_args,
**asorted_reverse)
Return the items of adict sorted
alphabetically, case-insensitively and in ascending
order. |
|
|
|
|
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=" ". |
|
|
|
|
km2m(km)
Convert kilo meter to meter (m). |
|
|
|
|
latDMS(deg,
form='dms',
prec=None,
sep='',
**s_D_M_S)
Convert latitude to a string, optionally suffixed with N or S. |
|
|
|
|
latlon2n_xyz(lat_ll,
lon=None,
**name)
Convert lat-, longitude to n-vector (normal to
the earth's surface) X, Y and Z components. |
|
|
|
|
latlonDMS(lls,
**m_form_prec_sep_s_D_M_S)
Convert one or more LatLon instances to strings. |
|
|
|
|
latlonDMS_(*lls,
**m_form_prec_sep_s_D_M_S)
Convert one or more LatLon instances to strings. |
|
|
|
|
len2(items)
Make built-in function len work for
generators, iterators, etc. |
|
|
|
|
|
|
|
lonDMS(deg,
form='dms',
prec=None,
sep='',
**s_D_M_S)
Convert longitude to a string, optionally suffixed with E or W. |
|
|
|
|
lrstrip(txt,
lrpairs={'(': ')', '<': '>', '[': ']', '{': '}'})
Left- and right-strip parentheses, brackets, etc. |
|
|
|
|
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). |
|
|
|
|
m2acre(meter2)
Convert square meter to acres. |
|
|
|
|
m2chain(meter)
Convert meter to UK chains. |
|
|
|
|
m2degrees(distance,
radius=6371008.771415,
lat=0)
Convert a distance to an angle along the equator or along a parallel
at (geodetic) latitude. |
|
|
|
|
m2fathom(meter)
Convert meter to Imperial fathoms. |
|
|
|
|
m2ft(meter,
usurvey=False,
pied=False,
fuss=False)
Convert meter to International, US Survey,
French or or German feet (ft). |
|
|
|
|
|
|
|
m2ha(meter2)
Convert square meter to hectare. |
|
|
|
|
m2km(meter)
Convert meter to kilo meter (Km). |
|
|
|
|
m2radians(distance,
radius=6371008.771415,
lat=0)
Convert a distance to an angle along the equator or along a parallel
at (geodetic) latitude. |
|
|
|
|
|
|
|
m2yard(meter)
Convert meter to UK yards. |
|
|
|
|
machine()
Return standard platform.machine, but distinguishing
Intel native from Intel emulation on Apple Silicon (on
macOS only). |
|
|
|
|
map1(fun1,
*xs)
Call a single-argument function to each xs and
return a tuple of results. |
|
|
|
|
map2(fun,
*xs,
**strict)
Like Python's map but returning a
tuple of results. |
|
|
|
|
max2(*xs)
Return 2-tuple (max(xs), xs.index(max(xs))). |
|
|
|
|
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. |
|
|
|
|
min2(*xs)
Return 2-tuple (min(xs), xs.index(min(xs))). |
|
|
|
|
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_xyz,
y=0,
z=0,
**name)
Convert n-vector to (geodetic) lat- and longitude in
degrees. |
|
|
|
|
n_xyz2philam(x_xyz,
y=0,
z=0,
**name)
Convert n-vector to (geodetic) 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,
adjust=True,
limit=9,
**LatLon_and_kwds)
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,
neg0=None)
Negate x and optionally, negate 0.0 and
-0.0. |
|
|
|
|
|
|
|
nonfiniterrors(raiser=None)
Throw OverflowError and ValueError
exceptions for or handle non-finite floats as
inf, INF, NINF,
nan and NAN in summations and
multiplications. |
|
|
|
|
norm2(x,
y)
Normalize a 2-dimensional vector. |
|
|
|
|
normDMS(strDMS,
norm=None,
**s_D_M_S)
Normalize all degrees, minutes and seconds (DMS) symbol
suffixes in a string to the default symbols S_DEG, S_MIN, S_SEC. |
|
|
|
|
norm_(*xs)
Normalize the components of an n-dimensional vector. |
|
|
|
|
normal(lat,
lon,
**name)
Normalize a lat- and longitude pair in degrees. |
|
|
|
|
normal_(phi,
lam,
**name)
Normalize a lat- and longitude pair in radians. |
|
|
|
|
notImplemented(inst,
*args,
**kwds)
Raise a NotImplementedError for a missing instance
method or property or for a missing caller feature. |
|
|
|
|
notOverloaded(inst,
*args,
**kwds)
Raise an AssertionError for a method or property not
overloaded. |
|
|
|
|
opposing(bearing1,
bearing2,
margin=90.0)
Compare the direction of two bearings given in degrees. |
|
|
|
|
opposing_(radians1,
radians2,
margin=1.5707963267948966)
Compare the direction of two bearings given in radians. |
|
|
|
|
pairs(items,
prec=6,
fmt='F',
ints=False,
sep='=')
Convert items to name=value strings, with floats
handled like fstr. |
|
|
|
|
parse3d(str3d,
sep=',',
Vector=<class 'pygeodesy.vector3d.Vector3d'>,
**Vector_kwds)
Parse an "x, y, z" string. |
|
|
|
|
parse3llh(strllh,
height=0,
sep=',',
clipLat=90,
clipLon=180,
wrap=False,
**s_D_M_S)
Parse a string "lat, lon [, h]" representing
lat-, longitude in degrees and optional height in
meter. |
|
|
|
|
parseDDDMMSS(strDDDMMSS,
suffix='NSEW',
sep='',
clip=0,
sexagecimal=False)
Parse a lat- or longitude represention forms as [D]DDMMSS in degrees. |
|
|
|
|
parseDMS(strDMS,
suffix='NSEW',
sep='',
clip=0,
**s_D_M_S)
Parse a lat- or longitude representation in degrees. |
|
|
|
|
parseDMS2(strLat,
strLon,
sep='',
clipLat=90,
clipLon=180,
wrap=False,
**s_D_M_S)
Parse a lat- and a longitude representions "lat,
lon" in degrees. |
|
|
|
|
parseETM5(strUTM,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...,
Etm=<class 'pygeodesy.etm.Etm'>,
falsed=True,
**name)
Parse a string representing a UTM coordinate, consisting of
"zone[band] hemisphere easting northing". |
|
|
|
|
parseMGRS(strMGRS,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...,
Mgrs=<class 'pygeodesy.mgrs.Mgrs'>,
**name)
Parse a string representing a MGRS grid reference, consisting of
"[zone]Band, EN, easting, northing". |
|
|
|
|
parseOSGR(strOSGR,
Osgr=<class 'pygeodesy.osgr.Osgr'>,
**name_Osgr_kwds)
Parse a string representing an OS Grid Reference, consisting of
"[GD] 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.771415,
wrap=True)
Approximate the perimeter of a path, polygon. |
|
|
|
|
|
|
|
philam2n_xyz(phi_ll,
lam=None,
**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,
eps=2.220446049250313e-16,
**Clas_and_kwds)
3-Point resection using Pierlot's method ToTal with
approximate limits for the (pseudo-)singularities. |
|
|
|
|
pierlotx(point1,
point2,
point3,
alpha1,
alpha2,
alpha3,
useZ=False,
**Clas_and_kwds)
3-Point resection using Pierlot's method ToTal with
exact limits for the (pseudo-)singularities. |
|
|
|
|
points2(points,
closed=True,
base=None,
Error=<class 'pygeodesy.errors.PointsError'>)
Check a path or polygon represented by points. |
|
|
|
|
|
|
|
precision(res)
Determine the Georef precision to meet a required (geographic)
resolution. |
|
|
|
|
print_(*args,
**nl_nt_prec_prefix__end_file_flush_sep__kwds)
Python 3+ print-like formatting and printing. |
|
|
|
|
printf(fmt,
*args,
**nl_nt_prec_prefix__end_file_flush_sep__kwds)
Printf-style and Python 3+ print-like
formatting and printing. |
|
|
|
|
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.771415,
lat=0)
Convert an angle to a distance along the equator or along a parallel
at (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. |
|
|
|
|
|
|
|
|
|
|
remainder(x,
y)
Mimick Python 3.7+ math.remainder. |
|
|
|
|
reprs(objs,
prec=6,
fmt='F',
ints=False)
Convert objects to repr strings, with
floats handled like fstr. |
|
|
|
|
rtp2xyz(r_rtp,
theta=0,
phi=0,
**name_Cartesian_and_kwds)
Convert spherical, polar (r, theta, phi) to
cartesian (x, y, z) coordinates. |
|
|
|
|
rtp2xyz_(r_rtp,
theta=0,
phi=0,
**name_Cartesian_and_kwds)
Convert spherical, polar (r, theta, phi) to
cartesian (x, y, z) coordinates. |
|
|
|
|
scalar(value,
low=2.220446049250313e-16,
high=1.0,
name='scalar',
Error=<type 'exceptions.ValueError'>)
DEPRECATED, use class Number_ or Scalar_. |
|
|
|
|
signBit(x)
Return signbit(x), like C++. |
|
|
|
|
signOf(x)
Return sign of x as int. |
|
|
|
|
simplify1(points,
distance=0.001,
radius=6371008.771415,
indices=False,
**options)
Basic simplification of a path of LatLon points by
eliminating any points closer together than the given distance
tolerance. |
|
|
|
|
|
|
|
simplifyRDP(points,
distance=0.001,
radius=6371008.771415,
shortest=False,
indices=False,
modified=False,
**options)
Ramer-Douglas-Peucker (RDP) simplification of a path of
LatLon points by eliminating any points too close
together or closer to an edge than the given distance
tolerance. |
|
|
|
|
|
|
|
simplifyRW(points,
pipe=0.001,
radius=6371008.771415,
shortest=False,
indices=False,
**options)
Reumann-Witkam (RW) simplification of a path of
LatLon points by eliminating any points too close
together or within the given pipe tolerance along an edge. |
|
|
|
|
simplifyVW(points,
area=0.001,
radius=6371008.771415,
indices=False,
attr=None,
modified=False,
**options)
Visvalingam-Whyatt (VW) simplification of a path of
LatLon points by eliminating any points too close or
with a triangular area not exceeding the given area tolerance
squared. |
|
|
|
|
|
|
|
sincos2(rad)
Return the sine and cosine of an angle in
radians. |
|
|
|
|
sincos2_(*rads)
Yield the sine and cosine of angle(s) in
radians. |
|
|
|
|
sincos2d(deg,
adeg=0.0)
Return the sine and cosine of an angle in
degrees. |
|
|
|
|
sincos2d_(*degs)
Yield the sine and cosine of angle(s) in
degrees. |
|
|
|
|
sincostan3(rad)
Return the sine, cosine and
tangent of an angle in radians. |
|
|
|
|
sincostan3d(deg)
Return the sine, cosine and
tangent of an angle in degrees. |
|
|
|
|
|
|
|
soddy4(point1,
point2,
point3,
eps=8.881784197001252e-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(x,
Error=None)
Return the square root sqrt(x) iff x
> EPS02, preserving type(x). |
|
|
|
|
sqrt3(x)
Return the square root, cubed sqrt(x)**3
or sqrt(x**3), preserving
type(x). |
|
|
|
|
sqrt_a(h,
b)
Compute a side of a right-angled triangle from
sqrt(h**2 - b**2). |
|
|
|
|
str2ub(arg)
(INTERNAL) Helper, no-op. |
|
|
|
|
strs(objs,
prec=6,
fmt='F',
ints=False)
Convert objects to str strings, with floats
handled like fstr. |
|
|
|
|
sumOf(vectors,
Vector=<class 'pygeodesy.vector3d.Vector3d'>,
**Vector_kwds)
Compute the vectorial sum of two oe more vectors. |
|
|
|
|
tan(rad,
**raiser_kwds)
Return the tangent of an angle in radians. |
|
|
|
|
tanPI_2_2(rad)
Compute the tangent of half angle, 90 degrees rotated. |
|
|
|
|
tan_(*rads,
**raiser_kwds)
Yield the tangent of angle(s) in radians. |
|
|
|
|
tan_2(rad,
**semi)
Compute the tangent of half angle. |
|
|
|
|
tand(deg,
**raiser_kwds)
Return the tangent of an angle in degrees. |
|
|
|
|
tand_(*degs,
**raiser_kwds)
Yield 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. |
|
|
|
|
|
|
|
tienstra7(pointA,
pointB,
pointC,
alpha,
beta=None,
gamma=None,
useZ=False,
**Clas_and_kwds)
3-Point resection using Tienstra's formula. |
|
|
|
|
toCss(latlon,
cs0=None,
height=None,
Css=<class 'pygeodesy.css.Css'>,
**name)
Convert an (ellipsoidal) geodetic point to a Cassini-Soldner
location. |
|
|
|
|
toDMS(deg,
form='dms',
prec=2,
sep='',
ddd=2,
neg='-',
pos='+',
**s_D_M_S)
Convert signed degrees to string, without suffix. |
|
|
|
|
toEtm8(latlon,
lon=None,
datum=None,
Etm=<class 'pygeodesy.etm.Etm'>,
falsed=True,
strict=True,
zone=None,
**name_cmoff)
Convert a geodetic lat-/longitude 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(utmups,
Mgrs=<class 'pygeodesy.mgrs.Mgrs'>,
**name_Mgrs_kwds)
Convert a UTM or UPS coordinate to an MGRS grid reference. |
|
|
|
|
toOsgr(latlon,
lon=None,
kTM=False,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...,
Osgr=<class 'pygeodesy.osgr.Osgr'>,
**prec_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,
strict=True,
zone=None,
**name_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,
earth=6378137.0,
Wm=<class 'pygeodesy.webmercator.Wm'>,
**name_Wm_kwds_radius)
Convert a lat-/longitude point to a WM coordinate. |
|
|
|
|
|
|
|
trfTransform0(reframe,
reframe2,
epoch=None,
epoch2=None,
indirect=True,
inverse=True,
exhaust=False)
Get a Helmert transform to convert one reframe observed
at epoch to an other reframe2 at observed
at epoch2 or epoch. |
|
|
|
|
trfTransforms(reframe,
reframe2,
epoch=None,
epoch2=None,
indirect=True,
inverse=True,
exhaust=False)
Yield all Helmert transform to convert one reframe
observed at epoch to an other reframe2 at
observed at epoch2 or epoch. |
|
|
|
|
trfXform(reframe1,
reframe2,
epoch=None,
xform=None,
rates=None,
raiser=True)
Define a new Terrestrial Reference Frame (TRF) converter or get an
existing one. |
|
|
|
|
triAngle(a,
b,
c)
Compute one angle of a triangle. |
|
|
|
|
|
|
|
triAngle5(a,
b,
c)
Compute the angles of a triangle. |
|
|
|
|
triArea(a,
b,
c)
Compute the area of a triangle using Heron's stable formula. |
|
|
|
|
triSide(a,
b,
radC)
Compute one side of a triangle. |
|
|
|
|
triSide2(b,
c,
radB)
Compute a side and its opposite angle of a triangle. |
|
|
|
|
triSide4(radA,
radB,
c)
Compute two sides and the height of a triangle. |
|
|
|
|
triaxum5(points,
useZ=True)
Best-fit a triaxial ellipsoid through three or more (3-D) points. |
|
|
|
|
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.220446049250313e-16,
**Vector_and_kwds)
Trilaterate three spheres, each given as a (3-D) center and a radius. |
|
|
|
|
truncate(x,
ndigits=None)
Truncate to the given number of digits. |
|
|
|
|
tyr3d(tilt=0,
yaw=0,
roll=0,
Vector=<class 'pygeodesy.vector3d.Vector3d'>,
**name_Vector_kwds)
Convert an attitude pose into a (3-D) direction vector. |
|
|
|
|
ub2str(arg)
(INTERNAL) Helper, no-op. |
|
|
|
|
|
|
|
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(where,
*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.771415,
wrap=False)
Compute the 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 [-90..+90]. |
|
|
|
|
wrapPI(rad)
Wrap radians to [-PI..+PI]. |
|
|
|
|
wrapPI2(rad)
Wrap radians to [0..+2PI). |
|
|
|
|
wrapPI_2(rad)
Wrap radians to [-PI/2..+PI/2]. |
|
|
|
|
wrap_normal(*normal)
Define the operation for the keyword argument
wrap=True, across pygeodesy: wrap, normalize or
no-op. |
|
|
|
|
xyz2rtp(x_xyz,
y=0,
z=0,
**name)
Convert cartesian (x, y, z) to spherical, polar
(r, theta, phi) coordinates. |
|
|
|
|
xyz2rtp_(x_xyz,
y=0,
z=0,
**name)
Convert cartesian (x, y, z) to spherical, polar
(r, theta, phi) coordinates. |
|
|
|
|
yard2m(yards)
Convert UK yards to meter. |
|
|
|
|
zcrt(x)
Return the 6-th, zenzi-cubic root, x**(1 /
6), preserving type(x). |
|
|
|
|
zqrt(x)
Return the 8-th, zenzi-quartic or squared-quartic root,
x**(1 / 8), preserving
type(x). |
|
|
