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.
PyPy 7.3.12 (Python 3.10.12), Python 3.11.5, 3.10.8 and 3.9.6 ran on
Apple M1 Silicon (arm64), natively. Python 3.8.10
and 2.7.18 ran on Intel (x86_64) or Intel emulation
("arm64_x86_64", see function pygeodesy.machine).
Previously, the tests were run with Python 3.12.0-1, 3.11.2-4,
3.10.1-7, 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-3.1 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.
|
|
VincentyError
Error raised by 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.
|
|
|
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 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.
|
|
|
AuxError
Error raised for a rhumb.aux_,
Aux, AuxDLat or AuxLat
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.
|
|
|
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.
|
|
|
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.
|
|
|
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.
|
|
|
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.
|
|
|
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.
|
|
|
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, further referred to 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 power=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.
|
|
|
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
DEPRECATED, use an other Frechet* class.
|
|
|
FrechetDistanceTo
Compute the Frechet distance based on the distance
from the point1s' 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.Geodesic Inverse method.
|
|
|
FrechetRadians
DEPRECATED, use an other Frechet* class.
|
|
|
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_.
|
|
|
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 and running summation.
|
|
|
Fsum2Tuple
2-Tuple (fsum, residual) with the precision running
fsum and the residual, the sum of the
remaining partials.
|
|
|
Fwelford
Welford's accumulator computing the running mean,
(sample) variance and standard deviation.
|
|
|
GDict
A dict with both key and
attribute access to the dict items.
|
|
|
GeodSolve12Tuple
12-Tuple (lat1, lon1, azi1, lat2, lon2, azi2, s12, a12, m12,
M12, M21, S12) with angles lat1,
lon1, azi1, lat2,
lon2 and azi2 and arc a12
all in degrees, initial azi1 and final
azi2 forward azimuths, distance s12 and
reduced length m12 in meter, area
S12 in meter squared and geodesic
scale factors M12 and M21, both
scalar, see GeodSolve.
|
|
|
GeodesicAreaExact
Area and perimeter of a geodesic polygon, an enhanced version of
Karney's Python class PolygonArea using the more accurate surface area.
|
|
|
GeodesicError
Error raised for lack of convergence or other issues in pygeodesy.geodesicx, pygeodesy.geodesicw or pygeodesy.karney.
|
|
|
GeodesicExact
A pure Python version of Karney's C++ class GeodesicExact, modeled after Karney's
Python class geodesic.Geodesic.
|
|
|
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.
|
|
|
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.
|
|
|
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_.
|
|
|
HeightIDWexact
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in degrees from method GeodesicExact.Inverse.
|
|
|
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 method Geodesic.Inverse.
|
|
|
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.
|
|
|
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.
|
|
|
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 line or circle intersection issues.
|
|
|
Inverse10Tuple
10-Tuple (a12, s12, salp1, calp1, salp2, calp2, m12, M12,
M21, S12) with arc length a12 in
degrees, distance s12 and reduced length
m12 in meter, area S12 in
meter squared and the sines salp1,
salp2 and cosines calp1,
calp2 of the initial 1 and final
2 (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_
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, gamma, scale) in
degrees90, degrees180, Datum,
degrees and float.
|
|
|
LatLonFHP
A point or intersection in a BooleanFHP clip or composite.
|
|
|
LatLonGH
A point or intersection in a BooleanGH clip or composite.
|
|
|
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 pygeodesy.equirectangular, pygeodesy.equirectangular_,
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.
|
|
|
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.
|
|
|
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 issues.
|
|
|
Number_
Named int representing a non-negative number.
|
|
|
Numpy2LatLon
Wrapper for NumPy arrays as "on-the-fly"
LatLon points.
|
|
|
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
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, 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 pygeodesy.parse3llh, pygeodesy.parseDMS, pygeodesy.parseDMS2 and pygeodesy.parseRad or the given
limit in functions pygeodesy.clipDegrees and pygeodesy.clipRadians.
|
|
|
RefFrame
Terrestrial Reference Frame (TRF) parameters.
|
|
|
ResectionError
Error raised for issues in pygeodesy.resections.
|
|
|
ResidualError
Error raised for an operation involving a pygeodesy.sums.Fsum instance with a non-zero
residual, integer or otherwise.
|
|
|
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
|
|
|
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 pygeodesy.rhumb.aux_, pygeodesy.rhumb.ekx or pygeodesy.rhumb.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.
|
|
|
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.
|
|
|
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.
|
|
|
TransformXform
Helmert transformation, extended with an Xform TRF
converter.
|
|
|
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, inter- or resection issues.
|
|
|
Triaxial
Ordered triaxial ellipsoid.
|
|
|
TriaxialError
Raised for Triaxial issues.
|
|
|
Triaxial_
Unordered triaxial ellipsoid and base class.
|
|
|
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.
|
|
|
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.
|
|
|
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),
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
|
|
|
Geodesic(a_ellipsoid,
f=None,
name='')
Return a wrapped geodesic.Geodesic instance from
Karney's Python geographiclib, provide the latter is installed,
otherwise an ImportError. |
|
|
|
|
GeodesicLine(geodesic,
lat1,
lon1,
azi1,
caps=3979)
Return a wrapped geodesicline.GeodesicLine
instance from Karney's Python geographiclib, provided the latter is installed,
otherwise an ImportError. |
|
|
|
|
Geodesic_WGS84()
Get the wrapped Geodesic(WGS84) singleton, provided geographiclib is installed, otherwise an
ImportError. |
|
|
|
|
NM2m(nm)
Convert nautical miles to meter (m). |
|
|
|
|
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. |
|
|
|
|
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. |
|
|
|
|
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 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 a (spherical) start and end point. |
|
|
|
|
bearingDMS(bearing,
form='d',
prec=None,
sep='',
**s_D_M_S)
Convert bearing to a string (without compass point suffix). |
|
|
|
|
bearing_(phi1,
lam1,
phi2,
lam2,
final=False,
wrap=False)
Compute the initial or final bearing (forward or reverse azimuth)
between a (spherical) start and end point. |
|
|
|
|
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). |
|
|
|
|
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). |
|
|
|
|
cbrt2(x)
Compute the cube root squared x**(2/3). |
|
|
|
|
centroidOf(points,
wrap=False,
LatLon=None)
Determine the centroid of a polygon. |
|
|
|
|
chain2m(chains)
Convert UK chains to meter. |
|
|
|
|
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_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,
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='')
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. |
|
|
|
|
cosineAndoyerLambert(lat1,
lon1,
lat2,
lon2,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran...,
wrap=False)
Compute the distance between two (ellipsoidal) points using the Andoyer-Lambert correction of the Law of Cosines formula. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cot(rad,
**error_kwds)
Return the cotangent of an angle in
radians. |
|
|
|
|
cot_(*rads,
**error_kwds)
Return the cotangent of angle(s) in
radiansresection. |
|
|
|
|
cotd(deg,
**error_kwds)
Return the cotangent of an angle in
degrees. |
|
|
|
|
cotd_(*degs,
**error_kwds)
Return the cotangent of angle(s) in
degrees. |
|
|
|
|
crosserrors(raiser=None)
Report or ignore vectorial cross product errors. |
|
|
|
|
date2epoch(year,
month,
day)
Return the 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 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 [-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. |
|
|
|
|
euclidean_(phi2,
phi1,
lam21,
adjust=True)
Approximate the angular 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. |
|
|
|
|
f2n(f)
Return n, the 3rd flattening for a given
flattening. |
|
|
|
|
f_2f(f_)
Return f, the flattening for a given inverse
flattening. |
|
|
|
|
|
|
|
|
|
|
fatan(x)
Fast approximation of atan(x). |
|
|
|
|
fatan1(x)
Fast approximation of atan(x) for 0 <=
x <= 1, unchecked. |
|
|
|
|
fatan2(y,
x)
Fast approximation of atan2(y, x). |
|
|
|
|
fathom2m(fathoms)
Convert Imperial fathom to meter. |
|
|
|
|
favg(v1,
v2,
f=0.5)
Return the average of two values. |
|
|
|
|
fdot(a,
*b)
Return the precision dot product sum(a[i] * b[i] for
i=0..len(a)). |
|
|
|
|
fdot3(a,
b,
c,
start=0)
Return the precision dot product start + sum(a[i] *
b[i] * c[i] for i=0..len(a)-1). |
|
|
|
|
fhorner(x,
*cs)
Evaluate the polynomial sum(cs[i] * x**i for
i=0..len(cs)-1) using the Horner form. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
float0_(*xs)
Yield xs as a non-NEG0 float. |
|
|
|
|
float_(*fs,
**sets)
Get scalars as float or intern'ed
float. |
|
|
|
|
fmean(xs)
Compute the accurate mean sum(xs) / len(xs). |
|
|
|
|
fmean_(*xs)
Compute the accurate mean sum(xs) / len(xs). |
|
|
|
|
fpolynomial(x,
*cs,
**over)
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]. |
|
|
|
|
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. |
|
|
|
|
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)
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,
floats=False)
Precision floating point summation based on or like Python's
math.fsum. |
|
|
|
|
fsum1(xs,
floats=False)
Precision floating point summation, 1-primed. |
|
|
|
|
fsum1_(*xs,
**floats)
Precision floating point summation, 1-primed. |
|
|
|
|
fsum1f_(*xs)
Precision floating point summation, fsum1_(*xs, floats=True), but
only for xs known to be scalar. |
|
|
|
|
fsum_(*xs,
**floats)
Precision floating point summation of all positional arguments. |
|
|
|
|
fsumf_(*xs)
Precision floating point summation, fsum_(*xs, floats=True), but
only for xs known to be scalar. |
|
|
|
|
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). |
|
|
|
|
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 0x7fa4881ef450>)
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. |
|
|
|
|
haversine_(phi2,
phi1,
lam21)
Compute the angular 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_ll,
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 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. |
|
|
|
|
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 obj some Cartesian? |
|
|
|
|
isDEPRECATED(obj)
Return True if obj is a
DEPRECATED class, method or function, False
if not or None if undetermined. |
|
|
|
|
isError(exc)
Check a (caught) exception. |
|
|
|
|
isLatLon(obj,
ellipsoidal=None)
Is obj some LatLon? |
|
|
|
|
isNumpy2(obj)
Check for a Numpy2LatLon points wrapper. |
|
|
|
|
isNvector(obj,
ellipsoidal=None)
Is obj 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)
Check whether an object is boolean. |
|
|
|
|
isclass(obj)
Return True if obj is 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)
Check whether an object is a complex or complex
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 or complex value. |
|
|
|
|
isfloat(obj)
Check whether an object is a float or float
str. |
|
|
|
|
isidentifier(obj)
Return True if obj is a Python
identifier. |
|
|
|
bool
|
isinf(x)
Check if float x is infinite (positive or negative). |
|
|
|
|
isinstanceof(obj,
*classes)
Is ob an instance of one of the
classes? |
|
|
|
|
isint(obj,
both=False)
Check for int type or an integer float
value. |
|
|
|
|
isint0(obj,
both=False)
Check for INT0 or int(0) value. |
|
|
|
|
|
|
|
islistuple(obj,
minum=0)
Check for list or tuple type with a minumal 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. |
|
|
|
|
|
|
|
|
|
|
isstr(obj)
Check for string types. |
|
|
|
|
issubclassof(Sub,
*Supers)
Check whether a class is a 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. |
|
|
|
|
|
|
|
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,
lon,
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). |
|
|
|
|
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 the
parallel at an other (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). |
|
|
|
|
|
|
|
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 the
parallel at an other (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)
Apply a single-argument function to each xs and
return a tuple of results. |
|
|
|
|
map2(fun,
*xs)
Apply a function to arguments 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,
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. |
|
|
|
|
|
|
|
norm2(x,
y)
Normalize a 2-dimensional vector. |
|
|
|
|
normDMS(strDMS,
norm=None,
**s_D_M_S)
Normalize all degrees, minutes and seconds (DMS) symbols in a
string to the default symbols S_DEG, S_MIN, S_SEC. |
|
|
|
|
norm_(*xs)
Normalize all n-dimensional vector components. |
|
|
|
|
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,
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,
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(form,
prec=None)
Set the default precison for a given F_ form. |
|
|
|
|
print_(*args,
**nl_nt_prefix_end_file_flush_sep)
Python 3+ print-like formatting and printing. |
|
|
|
|
printf(fmt,
*args,
**nl_nt_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 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. |
|
|
|
|
|
|
|
|
|
|
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_phi,
**name_Cartesian_and_kwds)
Convert spherical, polar (r, theta, phi) to
cartesian (x, y, z) coordinates. |
|
|
|
|
rtp2xyz_(r_rtp,
*theta_phi,
**name_Cartesian_and_kwds)
Convert spherical, polar (r, theta, phi) to
cartesian (x, y, z) coordinates. |
|
|
|
|
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. |
|
|
|
|
simplifyRDP(points,
distance=0.001,
radius=6371008.771415,
shortest=False,
indices=False,
**options)
Ramer-Douglas-Peucker (RDP) simplification of a path of
LatLon points. |
|
|
|
|
simplifyRDPm(points,
distance=0.001,
radius=6371008.771415,
shortest=False,
indices=False,
**options)
Modified Ramer-Douglas-Peucker (RDPm) simplification of a path
of LatLon points. |
|
|
|
|
simplifyRW(points,
pipe=0.001,
radius=6371008.771415,
shortest=False,
indices=False,
**options)
Reumann-Witkam (RW) simplification of a path of
LatLon points. |
|
|
|
|
simplifyVW(points,
area=0.001,
radius=6371008.771415,
attr=None,
indices=False,
**options)
Visvalingam-Whyatt (VW) simplification of a path of
LatLon points. |
|
|
|
|
simplifyVWm(points,
area=0.001,
radius=6371008.771415,
attr=None,
indices=False,
**options)
Modified Visvalingam-Whyatt (VWm) simplification of a path of
LatLon points. |
|
|
|
|
sincos2(rad)
Return the sine and cosine of an angle in
radians. |
|
|
|
|
sincos2_(*rads)
Return the sine and cosine of angle(s) in
radians. |
|
|
|
|
sincos2d(deg,
**adeg)
Return the sine and cosine of an angle in
degrees. |
|
|
|
|
sincos2d_(*degs)
Return the sine and cosine of angle(s) in
degrees. |
|
|
|
|
sincostan3(rad)
Return the sine, cosine and
tangent of an angle in radians. |
|
|
|
|
|
|
|
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 iff x > EPS02. |
|
|
|
|
sqrt3(x)
Return the square root, cubed sqrt(x)**3
or sqrt(x**3). |
|
|
|
|
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. |
|
|
|
|
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. |
|
|
|
|
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,
name='',
strict=True,
zone=None,
**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'>,
name='',
**prec_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. |
|
|
|
|
toUtm8(latlon,
lon=None,
datum=None,
Utm=<class 'pygeodesy.utm.Utm'>,
falsed=True,
name='',
strict=True,
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,
earth=6378137.0,
Wm=<class 'pygeodesy.webmercator.Wm'>,
name='',
**Wm_kwds)
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. |
|
|
|
|
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'>,
**Vector_kwds)
Convert an attitude oriention 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. |
|
|
|
|
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 [-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_z,
**name)
Convert cartesian (x, y, z) to spherical, polar
(r, theta, phi) coordinates. |
|
|
|
|
xyz2rtp_(x_xyz,
*y_z,
**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). |
|
|
|
|
zqrt(x)
Return the 8-th, zenzi-quartic or squared-quartic root,
x**(1 / 8). |
|
|
