A pure Python implementation of geodesy tools for various ellipsoidal
and spherical earth models using precision trigonometric, vector-based,
elliptic and approximate methods for geodetic (lat-/longitude) and
geocentric (ECEF cartesian) coordinates.
Previously, the tests were run with Python 2.6.9 (and numpy 1.6.2),
2.7.10 (and numpy 1.8.0rc1), 2.7.13 thru 2.7.17 (with numpy 1.13.1,
1.14.0, 1.15.2, 1.16.2 or 1.19.0 and scipy 1.5.0), 3.5.3, 3.6.2 thru
3.6.5, 3.7.0, 3.7.2 thru 3.7.6, 3.8 thru 3.8.5, PyPy 6.0.0 (Python 2.7.13 and
3.5.3), PyPy 7.3.0 (Python
2.7.13 and 3.6.9) and Intel-Python 3.5.3 (and numpy 1.11.3)
on MacOS X 10.10 Yosemite, MacOS X 10.11 El Capitan, macOS 10.12
Sierra, macOS 10.13.6 High Sierra, macOS 10.14 Mojave and/or macOS
10.15.3, 10.15.5 and 10.15.6 Catalina, with Pythonista
3.1 on iOS 10.3.3, 11.0.3, 11.1.2 and 11.3 on iPad4, with Pythonista
3.2 (with geographiclib 1.49 or 1.50 and numpy 1.8.0) on iOS
11.4.1, 12.0, 12.2 and 12.3 on iPad4, iPhone6 and/or iPhone10, all in
64-bit only and with 32-bit Python 2.6.6 on Windows XP SP3 and with
32-bit Python 2.7.14 on Windows 10 Pro.
Some function and method names differ from the JavaScript version.
In such cases documentation tag JS name: shows the original
JavaScript name.
|
LazyImportError
Raised if lazy import is not supported, disabled or
failed some other way.
|
|
VincentyError
Error raised from Vincenty's direct and
inverse methods for coincident points or lack of
convergence.
|
|
Epsg
EPSG
class, a named int .
|
|
EPSGError
EPSG encode, decode or other Epsg issue.
|
|
Garef
Garef class, a named str .
|
|
GARSError
Global Area Reference System (GARS) encode, decode or other Garef
issue.
|
|
Geohash
Geohash class, a named str .
|
|
GeohashError
Geohash encode, decode or other Geohash issue.
|
|
Georef
Georef class, a named str .
|
|
WGRSError
World Geographic Reference System (WGRS) encode, decode or other Georef
issue.
|
|
AlbersEqualArea
An Albers equal-area (authalic) projection with a single standard
parallel.
|
|
AlbersEqualArea2
An Albers equal-area (authalic) projection with two standard
parallels.
|
|
AlbersEqualArea4
An Albers equal-area (authalic) projection specified by the
sin and cos of both standard parallels.
|
|
AlbersEqualAreaCylindrical
An AlbersEqualArea projection at lat=0
and k0=1 degenerating to the cylindrical-equal-area
projection.
|
|
AlbersEqualAreaNorth
An azimuthal AlbersEqualArea projection at lat=90
and k0=1 degenerating to the azimuthal
LambertEqualArea projection.
|
|
AlbersEqualAreaSouth
An azimuthal AlbersEqualArea projection at lat=-90
and k0=1 degenerating to the azimuthal
LambertEqualArea projection.
|
|
AlbersError
An AlbersEqualArea, AlbersEqualArea2, AlbersEqualArea4, AlbersEqualAreaCylindrical, AlbersEqualAreaNorth, AlbersEqualAreaSouth or Albers7Tuple issue.
|
|
AzimuthalError
An azimuthal Equidistant, EquidistantKarney, Gnomonic, LambertEqualArea, Orthographic, Stereographic or {Azimuthal7Tuple} issue.
|
|
Band
Named str representing a UTM/UPS band letter,
unchecked.
|
|
Bearing
Named float representing a bearing in compass
degrees from (true) North.
|
|
Bearing_
Named float representing a bearing in
radians from compass degrees from (true)
North.
|
|
Bool
Named bool , a sub-class of int like
Python's bool .
|
|
CSSError
Cassini-Soldner (CSS) conversion or other Css issue.
|
|
CassiniSoldner
Cassini-Soldner projection, a Python version of Karney's C++
class CassiniSoldner.
|
|
ClipError
Clip box or clip region issue.
|
|
Conic
Lambert conformal conic projection (1- or 2-SP).
|
|
CrossError
Error raised for zero or near-zero vectorial cross products,
occurring for coincident or colinear points, paths or bearings.
|
|
Css
Cassini-Soldner East-/Northing location.
|
|
Datum
Ellipsoid and transform parameters for an earth model.
|
|
Degrees
Named float representing a coordinate in
degrees , optionally clipped.
|
|
Degrees2
Named float representing a distance in degrees
squared .
|
|
Degrees_
Named Degrees representing a coordinate in
degrees with optional limits low and
high .
|
|
Distance
Named float representing a distance, conventionally in
meter .
|
|
Distance_
Named float with optional low and
high limits representing a distance, conventionally in
meter .
|
|
ETMError
Exact Transverse Mercator (ETM) parse, projection or other Etm issue.
|
|
Easting
Named float representing an easting, conventionally in
meter .
|
|
EcefCartesian
Conversion between geodetic (lat, lon, height) and
local cartesian (x, y, z) coordinates with a local
cartesian origin at (lat0, lon0, height0) , transcribed
from Karney's C++ class LocalCartesian.
|
|
EcefError
An ECEF or Ecef* related issue.
|
|
EcefKarney
Conversion between geodetic and geocentric, aka Earth-Centered,
Earth-Fixed (ECEF) coordinates based on Karney's Geocentric methods.
|
|
EcefMatrix
A rotation matrix.
|
|
EcefSudano
Conversion between geodetic and geocentric, aka Earth-Centered,
Earth-Fixed (ECEF) coordinates based on John J. Sudano's
paper.
|
|
EcefVeness
Conversion between geodetic and geocentric, aka Earth-Centered,
Earth-Fixed (ECEF) coordinates transcribed from Chris
Veness' JavaScript classes LatLonEllipsoidal, Cartesian.
|
|
EcefYou
Conversion between geodetic and geocentric, aka Earth-Centered,
Earth-Fixed (ECEF) coordinates using Rey-Jer You's transformations.
|
|
Ellipsoid
Ellipsoid with equatorial and polar radius,
flattening, inverse flattening and other, often used,
cached attributes, supporting spherical and oblate
and prolate ellipsoidal models.
|
|
Ellipsoid2
Like Ellipsoid, but specified by equatorial
radius and flattening.
|
|
Elliptic
Elliptic integrals and functions.
|
|
EllipticError
Elliptic integral, function, convergence or other Elliptic issue.
|
|
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.
|
|
EquidistantKarney
Azimuthal equidistant projection, a Python version of
Karney's C++ class AzimuthalEquidistant, requiring package geographiclib to be installed.
|
|
Etm
Exact Transverse Mercator (ETM) coordinate, a sub-class of Utm, a
Universal Transverse Mercator (UTM) coordinate using the ExactTransverseMercator projection for highest
accuracy.
|
|
ExactTransverseMercator
A Python version of Karney's TransverseMercatorExact C++ class, a numerically
exact transverse mercator projection, here referred to as
TMExact .
|
|
Fdot
Precision dot product.
|
|
Feet
Named float representing a distance or length in
feet .
|
|
Fhorner
Precision polynomial evaluation using the Horner form.
|
|
Float
Named float .
|
|
Float_
Named float with optional low and
high limit.
|
|
Fpolynomial
Precision polynomial evaluation.
|
|
Frechet
Frechet base class, requires method Frechet.distance to be overloaded.
|
|
FrechetCosineAndoyerLambert
Compute the Frechet distance based on the
angular distance in radians from function cosineAndoyerLambert_.
|
|
FrechetCosineForsytheAndoyerLambert
Compute the Frechet distance based on the
angular distance in radians from function cosineForsytheAndoyerLambert_.
|
|
FrechetCosineLaw
Compute the Frechet distance based on the
angular distance in radians from function cosineLaw_.
|
|
FrechetDegrees
Frechet base class for distances in
degrees from LatLon points in
degrees .
|
|
FrechetDistanceTo
Compute the Frechet distance based on the distance
from the points' LatLon.distanceTo method,
conventionally in meter .
|
|
FrechetEquirectangular
Compute the Frechet distance based on the
equirectangular distance in radians
squared like function equirectangular_.
|
|
FrechetError
Fréchet issue.
|
|
FrechetEuclidean
Compute the Frechet distance based on the
Euclidean distance in radians from
function euclidean_.
|
|
FrechetFlatLocal
Compute the Frechet distance based on the
angular distance in radians squared like
function flatLocal_/hubeny_.
|
|
FrechetFlatPolar
Compute the Frechet distance based on the
angular distance in radians from function flatPolar_.
|
|
FrechetHaversine
Compute the Frechet distance based on the
angular distance in radians from function haversine_.
|
|
FrechetHubeny
Compute the Frechet distance based on the
angular distance in radians squared like
function flatLocal_/hubeny_.
|
|
FrechetKarney
Compute the Frechet distance based on the
angular distance in degrees from
Karney's geographiclib Geodesic Inverse method.
|
|
FrechetRadians
Frechet base class for distances in
radians or radians squared from
LatLon points converted from degrees to
radians .
|
|
FrechetThomas
Compute the Frechet distance based on the
angular distance in radians from function thomas_.
|
|
FrechetVincentys
Compute the Frechet distance based on the
angular distance in radians from function vincentys_.
|
|
Fsum
Precision summation similar to standard Python function
math.fsum .
|
|
GeoidError
Geoid interpolator Geoid... or interpolation issue.
|
|
GeoidG2012B
Geoid height interpolator for GEOID12B Model grids CONUS, Alaska, Hawaii, Guam and Northern Mariana Islands, Puerto Rico and U.S. Virgin Islands and American Samoa based on SciPy RectBivariateSpline or interp2d interpolation.
|
|
GeoidKarney
Geoid height interpolator for Karney's GeographicLib Earth Gravitational Model (EGM)
geoid egm*.pgm datasets using bilinear or cubic interpolation and caching in pure Python transcribed from
Karney's C++ class Geoid.
|
|
GeoidPGM
Geoid height interpolator for Karney's GeographicLib Earth Gravitational Model (EGM)
geoid egm*.pgm datasets but based on SciPy
RectBivariateSpline or interp2d interpolation.
|
|
Gnomonic
Azimuthal gnomonic projection for the sphere**, see Snyder, pp 164-168 and MathWorld-Wolfram.
|
|
GnomonicKarney
Azimuthal gnomonic projection, a Python version of Karney's
C++ class Gnomonic, requiring package geographiclib to be installed.
|
|
Hausdorff
Hausdorff base class, requires method Hausdorff.distance to be overloaded.
|
|
HausdorffCosineAndoyerLambert
Compute the Hausdorff distance based on the
angular distance in radians from function cosineAndoyerLambert_.
|
|
HausdorffCosineForsytheAndoyerLambert
Compute the Hausdorff distance based on the
angular distance in radians from function cosineForsytheAndoyerLambert_.
|
|
HausdorffCosineLaw
Compute the Hausdorff distance based on the
angular distance in radians from function cosineLaw_.
|
|
HausdorffDegrees
Hausdorff base class for distances from
LatLon points in degrees .
|
|
HausdorffDistanceTo
Compute the Hausdorff distance based on the distance
from the points' LatLon.distanceTo method,
conventionally in meter .
|
|
HausdorffEquirectangular
Compute the Hausdorff distance based on the
equirectangular distance in radians
squared like function equirectangular_.
|
|
HausdorffError
Hausdorff issue.
|
|
HausdorffEuclidean
Compute the Hausdorff distance based on the
Euclidean distance in radians from
function euclidean_.
|
|
HausdorffFlatLocal
Compute the Hausdorff distance based on the
angular distance in radians squared like
function flatLocal_/hubeny_.
|
|
HausdorffFlatPolar
Compute the Hausdorff distance based on the
angular distance in radians from function flatPolar_.
|
|
HausdorffHaversine
Compute the Hausdorff distance based on the
angular distance in radians from function haversine_.
|
|
HausdorffHubeny
Compute the Hausdorff distance based on the
angular distance in radians squared like
function flatLocal_/hubeny_.
|
|
HausdorffKarney
Compute the Hausdorff distance based on the
angular distance in degrees from
Karney's geographiclib Geodesic Inverse method.
|
|
HausdorffRadians
Hausdorff base class for distances from
LatLon points converted from degrees to
radians .
|
|
HausdorffThomas
Compute the Hausdorff distance based on the
angular distance in radians from function thomas_.
|
|
HausdorffVincentys
Compute the Hausdorff distance based on the
angular distance in radians from function vincentys_.
|
|
Height
Named float representing a height, conventionally in
meter .
|
|
HeightCubic
Height interpolator based on SciPy interp2d kind='cubic' .
|
|
HeightError
Height interpolator Height... or interpolation issue.
|
|
HeightIDW
DEPRECATED, use class HeightIDWeuclidean.
|
|
HeightIDW2
DEPRECATED, use class HeightIDWequirectangular.
|
|
HeightIDW3
DEPRECATED, use class HeightIDWhaversine.
|
|
HeightIDWcosineAndoyerLambert
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function cosineAndoyerLambert_.
|
|
HeightIDWcosineForsytheAndoyerLambert
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function cosineForsytheAndoyerLambert_.
|
|
HeightIDWcosineLaw
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function cosineLaw_.
|
|
HeightIDWdistanceTo
Height interpolator using Inverse Distance Weighting (IDW) and the distance
from the points' LatLon.distanceTo method,
conventionally in meter .
|
|
HeightIDWequirectangular
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians squared like
function equirectangular_.
|
|
HeightIDWeuclidean
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function euclidean_.
|
|
HeightIDWflatLocal
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians squared like
function flatLocal_/hubeny_.
|
|
HeightIDWflatPolar
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function flatPolar_.
|
|
HeightIDWhaversine
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function haversine_.
|
|
HeightIDWhubeny
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians squared like
function flatLocal_/hubeny_.
|
|
HeightIDWkarney
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in degrees from
Karney's geographiclib Geodesic Inverse method.
|
|
HeightIDWthomas
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function thomas_.
|
|
HeightIDWvincentys
Height interpolator using Inverse Distance Weighting (IDW) and the
angular distance in radians from function vincentys_.
|
|
HeightLSQBiSpline
Height interpolator using SciPy LSQSphereBivariateSpline.
|
|
HeightLinear
Height interpolator based on SciPy interp2d kind='linear' .
|
|
HeightSmoothBiSpline
Height interpolator using SciPy SmoothSphereBivariateSpline.
|
|
Int
Named int .
|
|
Int_
Named int with optional limits low and
high .
|
|
IntersectionError
Error raised for path or circle intersection issues.
|
|
LCCError
Lambert Conformal Conic LCC or other Lcc issue.
|
|
Lam
Named float representing a longitude in
radians .
|
|
Lam_
Named float representing a longitude in
radians converted from degrees .
|
|
LambertEqualArea
Lambert-equal-area projection for the sphere**, see Snyder, pp 185-187 and MathWorld-Wolfram.
|
|
Lat
Named float representing a latitude in
degrees .
|
|
LatLon2psxy
Wrapper for LatLon points as "on-the-fly"
pseudo-xy coordinates.
|
|
LatLon_
Low-overhead LatLon class for Numpy2LatLon and Tuple2LatLon.
|
|
Lat_
Named float representing a latitude in
degrees within limits low and
high .
|
|
Lcc
Lambert conformal conic East-/Northing location.
|
|
LenError
Error raised for mis-matching len values.
|
|
LimitError
Error raised for lat- or longitudinal deltas exceeding the
limit in functions equirectangular and equirectangular_ and nearestOn* and
simplify* functions or methods.
|
|
Lon
Named float representing a longitude in
degrees .
|
|
Lon_
Named float representing a longitude in
degrees within limits low and
high .
|
|
MGRSError
Military Grid Reference System (MGRS) parse or other Mgrs issue.
|
|
Meter
Named float representing a distance or length in
meter .
|
|
Mgrs
Military Grid Reference System (MGRS/NATO) references, with method
to convert to UTM coordinates.
|
|
Northing
Named float representing a northing, conventionally in
meter .
|
|
Number_
Named int representing a non-negative number.
|
|
Numpy2LatLon
Wrapper for NumPy arrays as "on-the-fly"
LatLon points.
|
|
OSGRError
Ordinance Survey Grid References (OSGR) parse or other Osgr issue.
|
|
Orthographic
Orthographic projection for the sphere**, see Snyder, pp 148-153 and MathWorld-Wolfram.
|
|
Osgr
Ordinance Survey Grid References (OSGR) coordinate.
|
|
PGMError
Issue parsing or cropping an egm*.pgm geoid dataset.
|
|
ParseError
Error parsing degrees, radians or several other formats.
|
|
Phi
Named float representing a latitude in
radians .
|
|
Phi_
Named float representing a latitude in
radians converted from degrees .
|
|
PointsError
Error for an insufficient number of points.
|
|
Precision_
Named int with optional low and
high limits representing a precision.
|
|
Radians
Named float representing a coordinate in
radians , optionally clipped.
|
|
Radians2
Named float representing a distance in radians
squared .
|
|
Radius
Named float representing a radius, conventionally in
meter .
|
|
Radius_
Named float with optional low and
high limits representing a radius, conventionally in
meter .
|
|
RangeError
Error raised for lat- or longitude values outside the
clip , clipLat ,
clipLon or limit range in
function clipDegrees, clipRadians, parse3llh, parseDMS, parseDMS2 or parseRad.
|
|
RefFrame
Terrestrial Reference Frame (TRF) parameters.
|
|
RefFrameError
DEPRECATED, use class TRFError.
|
|
Scalar
Named float representing a factor, fraction, scale,
etc.
|
|
Scalar_
Named float with optional low and
high limits representing a factor, fraction, scale,
etc.
|
|
SciPyError
Error raised for SciPy errors.
|
|
SciPyWarning
Error thrown for SciPy warnings.
|
|
Stereographic
Stereographic projection for the sphere**, see Snyder, pp 157-160 and MathWorld-Wolfram.
|
|
Str
Named str .
|
|
TRFError
Terrestrial Reference Frame (TRF), Epoch, RefFrame
or RefFrame conversion issue.
|
|
Transform
Helmert transformation.
|
|
Tuple2LatLon
Wrapper for tuple sequences as "on-the-fly"
LatLon points.
|
|
UPSError
Universal Polar Stereographic (UPS) parse or other Ups issue.
|
|
UTMError
Universal Transverse Mercator (UTM parse or other Utm issue.
|
|
UTMUPSError
Universal Transverse Mercator/Universal Polar Stereographic
(UTM/UPS) parse, validate or other issue.
|
|
UnitError
Default exception for units issues.
|
|
Ups
Universal Polar Stereographic (UPS) coordinate.
|
|
Utm
Universal Transverse Mercator (UTM) coordinate.
|
|
Vector3d
Generic 3-D vector manipulation.
|
|
VectorError
Vector3d or *Nvector issue.
|
|
WebMercatorError
Web Mercator (WM) parser or Wm
issue.
|
|
Wm
Web Mercator (WM) coordinate.
|
|
Zone
Named int representing a UTM/UPS zone number.
|
|
a_f2Tuple
2-Tuple (a, f) specifying an ellipsoid by
equatorial radius a (meter ) and
scalar flattening f .
|
|
property_RO
|
|
UtmUps(zone,
hemipole,
easting,
northing,
band='
' ,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
falsed=True,
name='
' )
Class-like function to create a UTM/UPS coordinate. |
|
|
|
a_b2e(a,
b)
Return e , the eccentricity for a given
equatorial and polar radius. |
|
|
|
a_b2e2(a,
b)
Return e2 , the 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))). |
|
|
|
anStr(name,
OKd=' ._- ' ,
sub=' _ ' )
DEPRECATED, use function anstr. |
|
|
|
anstr(name,
OKd=' ._- ' ,
sub=' _ ' )
Make a valid name of alphanumeric and OKd characters. |
|
|
|
antipode(lat,
lon)
Return the antipode, the point diametrically opposite to a given
point in degrees . |
|
|
|
antipode_(phi,
lam)
Return the antipode, the point diametrically opposite to a given
point in radians . |
|
|
|
areaOf(points,
adjust=True,
radius=6371008.77141,
wrap=True)
Approximate the area of a polygon. |
|
|
|
areaof(points,
adjust=True,
radius=_R_M,
wrap=True)
DEPRECATED, use function areaOf. |
|
|
|
asin1(x)
Return math.asin(max(-1, min(1, x))). |
|
|
|
atan2b(y,
x)
Compute atan2(y, x) as degrees [0..+360]. |
|
|
|
atan2d(y,
x)
Compute atan2(y, x) as degrees [-180..+180]. |
|
|
|
attrs(inst,
*names,
**kwds)
Get instance attributes as name=value strings, with
float s handled like fstr. |
|
|
|
b_f2a(b,
f)
Return a , the equatorial radius for a given
polar radius and flattening. |
|
|
|
b_f_2a(b,
f_)
Return a , the equatorial radius for a given
polar radius and inverse flattening. |
|
|
|
bearing(lat1,
lon1,
lat2,
lon2,
**options)
Compute the initial or final bearing (forward or reverse azimuth)
between a (spherical) start and end point. |
|
|
|
bearingDMS(bearing,
form=' d ' ,
prec=None,
sep='
' )
Convert bearing to a string. |
|
|
|
bearing_(phi1,
lam1,
phi2,
lam2,
final=False,
wrap=False)
Compute the initial or final bearing (forward or reverse azimuth)
between a (spherical) start and end point. |
|
|
|
bounds(points,
wrap=True,
LatLon=None)
DEPRECATED, use function boundsOf. |
|
|
|
boundsOf(points,
wrap=True,
LatLon=None)
Determine the lower-left SW and upper-right NE corners of a path or
polygon. |
|
|
|
callername(up=1,
dflt='
' ,
source=False)
Get the name of the calling callable. |
|
|
|
cbrt(x)
Compute the cubic root x**(1/3). |
|
|
|
cbrt2(x)
Compute the cubic root squared x**(2/3). |
|
|
|
centroidOf(points,
wrap=True,
LatLon=None)
Determine the centroid of a polygon. |
|
|
|
classname(inst,
prefixed=None)
Return the instance' class name optionally prefixed with the module
name. |
|
|
|
classnaming(prefixed=None)
Get/set the default class naming for [module.]class
names. |
|
|
|
clipCS3(points,
lowerleft,
upperright,
closed=False,
inull=False)
Clip a path against a rectangular clip box using the Cohen-Sutherland algorithm. |
|
|
|
clipDMS(deg,
limit)
DEPRECATED, use function clipDegrees. |
|
|
|
clipDegrees(deg,
limit)
Clip a lat- or longitude to the given range. |
|
|
|
clipRadians(rad,
limit)
Clip a lat- or longitude to the given range. |
|
|
|
clipSH(points,
corners,
closed=False,
inull=False)
Clip a polygon against a clip region or box using the Sutherland-Hodgman algorithm. |
|
|
|
clipSH3(points,
corners,
closed=False,
inull=False)
Clip a polygon against a clip region or box using the Sutherland-Hodgman algorithm. |
|
|
|
clipStr(bstr,
limit=50,
white='
' )
DEPRECATED, use function clips. |
|
|
|
clips(bstr,
limit=50,
white='
' )
Clip a string to the given length limit. |
|
|
|
compassAngle(lat1,
lon1,
lat2,
lon2,
adjust=True,
wrap=False)
Return the angle from North for the direction vector (lon2 - lon1, lat2 - lat1) between two points. |
|
|
|
compassDMS(bearing,
form=' d ' ,
prec=None,
sep='
' )
Convert bearing to a string suffixed with compass point. |
|
|
|
compassPoint(bearing,
prec=3)
Convert bearing to a compass point. |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
crosserrors(raiser=None)
Report or ignore vectorial cross product errors. |
|
|
|
date2epoch(year,
month,
day)
Return the reference frame epoch for a calendar day. |
|
|
|
|
|
degDMS(deg,
prec=6,
s_D=' ° ' ,
s_M=' \xe2\x80\xb2 ' ,
s_S=' ″ ' ,
neg=' - ' ,
pos='
' )
Convert degrees to a string in degrees, minutes or
seconds. |
|
|
|
degrees(x)
Convert angle x from radians to degrees. |
|
|
|
degrees180(rad)
Convert radians to degrees and wrap [-180..+180]. |
|
|
|
degrees2m(deg,
radius=6371008.77141,
lat=0)
Convert angle to distance along the equator or along a parallel at an
other latitude. |
|
|
|
degrees360(rad)
Convert radians to degrees and wrap [0..+360). |
|
|
|
degrees90(rad)
Convert radians to degrees and wrap [-270..+90]. |
|
|
|
|
|
elevation2(lat,
lon,
timeout=2.0)
Get the geoid elevation at an NAD83 to
NAVD88 location. |
|
|
|
enStr2(easting,
northing,
prec,
*extras)
DEPRECATED, use function enstr2. |
|
|
|
|
|
enstr2(easting,
northing,
prec,
*extras)
Return easting, northing string representations. |
|
|
|
epoch2date(epoch)
Return the date for a reference frame epoch . |
|
|
|
|
|
|
|
equirectangular3(lat1,
lon1,
lat2,
lon2,
**options)
DEPRECATED, use function equirectangular_ . |
|
|
|
|
|
euclid(x,
y)
Appoximate the norm sqrt(x**2 + y**2) by
max(abs(x), abs(y)) + min(abs(x), abs(y)) *
0.4142.... |
|
|
|
euclid_(*xs)
Appoximate the norm sqrt(sum(x**2 for x in
xs)) by cascaded euclid. |
|
|
|
euclidean(lat1,
lon1,
lat2,
lon2,
radius=6371008.77141,
adjust=True,
wrap=False)
Approximate the Euclidean distance between two
(spherical) points. |
|
|
|
euclidean_(phi2,
phi1,
lam21,
adjust=True)
Approximate the angular Euclidean distance
between two (spherical) points. |
|
|
|
exception_chaining(error=None)
Get the previous exception's or exception chaining setting. |
|
|
|
f2e2(f)
Return e2 , the eccentricity squared for a given
flattening. |
|
|
|
f2e22(f)
Return e22 , the 2nd eccentricity squared for a
given flattening. |
|
|
|
f2e32(f)
Return e32 , the 3rd eccentricity squared for a
given flattening. |
|
|
|
f2f2(f)
Return f2 , the 2nd flattening for a given
flattening. |
|
|
|
f2f_(f)
Return f_ , the inverse flattening for a given
flattening. |
|
|
|
f2n(f)
Return n , the 3rd flattening for a given
flattening. |
|
|
|
fStr(floats,
prec=6,
fmt=' %.*f ' ,
ints=False,
sep=' , ' )
DEPRECATED, use function fstr. |
|
|
|
fStrzs(floatstr)
DEPRECATED, use function fstrzs. |
|
|
|
f_2f(f_)
Return f , the flattening for a given inverse
flattening. |
|
|
|
false2f(value,
name=' value ' ,
false=True,
Error=<type 'exceptions.ValueError'>)
DEPRECATED, use function falsed2f. |
|
|
|
falsed2f(falsed=True,
Error=<type 'exceptions.ValueError'>,
**name_value)
DEPRECATED, use class Easting or Northing. |
|
|
|
favg(v1,
v2,
f=0.5)
Return the average of two values. |
|
|
|
fdot(a,
*b)
Return the precision dot product sum(a[i] * b[i] for
i=0..len(a)). |
|
|
|
fdot3(a,
b,
c,
start=0)
Return the precision dot product start + sum(a[i] *
b[i] * c[i] for i=0..len(a)). |
|
|
|
fhorner(x,
*cs)
Evaluate the polynomial sum(cs[i] * x**i for
i=0..len(cs)) using the Horner form. |
|
|
|
|
|
|
|
|
|
|
|
|
|
fmean(xs)
Compute the accurate mean sum(xs[i] for i=0..len(xs))
/ len(xs). |
|
|
|
fpolynomial(x,
*cs)
Evaluate the polynomial sum(cs[i] * x**i for
i=0..len(cs)). |
|
|
|
fpowers(x,
n,
alts=0)
Return a series of powers [x**i for i=1..n]. |
|
|
|
fprod(iterable,
start=1.0)
Iterable product, like math.prod or
numpy.prod . |
|
|
|
fractional(points,
fi,
LatLon=None,
**LatLon_kwds)
Return the point at a given fractional index. |
|
|
|
frange(start,
number,
step=1)
Generate a range of float s. |
|
|
|
frechet_(points1,
points2,
distance=None,
units='
' )
Compute the discrete Fréchet distance between two paths given as sets of
points. |
|
|
value
|
freduce(function,
sequence,
initial=...)
Apply a function of two arguments cumulatively to the items of a
sequence, from left to right, so as to reduce the sequence to a
single value. |
|
|
|
fstr(floats,
prec=6,
fmt=' F ' ,
ints=False,
sep=' , ' ,
strepr=None)
Convert one or more floats to string, optionally stripped of trailing
zero decimals. |
|
|
|
fstrzs(efstr,
ap1z=False)
Strip trailing zero decimals from a float string. |
|
|
|
fsum(iterable)
Return an accurate floating point sum of values in the iterable. |
|
|
|
fsum_(*xs)
Precision summation of the positional argument vulues. |
|
|
|
ft2m(feet,
usurvey=False)
Convert International or US Survey feet to meter. |
|
|
|
geoidHeight2(lat,
lon,
model=0,
timeout=2.0)
Get the NAVD88 geoid height at an NAD83
location. |
|
|
|
|
|
halfs2(str2)
Split a string in 2 halfs. |
|
|
|
|
|
haversine(lat1,
lon1,
lat2,
lon2,
radius=6371008.77141,
wrap=False)
Compute the distance between two (spherical) points using the Haversine formula. |
|
|
|
haversine_(phi2,
phi1,
lam21)
Compute the angular distance between two (spherical) points
using the Haversine formula. |
|
|
|
heightOf(angle,
distance,
radius=6371008.77141)
Determine the height above the (spherical) earth after traveling
along a straight line at a given tilt. |
|
|
|
horizon(height,
radius=6371008.77141,
refraction=False)
Determine the distance to the horizon from a given altitude above the
(spherical) earth. |
|
|
|
hstr(height,
prec=2,
fmt=' %+.*f ' ,
ints=False,
m='
' )
Return a string for the height value. |
|
|
|
|
|
|
|
hypot(x,
y)
Return the Euclidean distance, sqrt(x*x + y*y). |
|
|
|
hypot1(x)
Compute the norm sqrt(1 + x**2). |
|
|
|
hypot2(x,
y)
Compute the squared norm x**2 + y**2. |
|
|
|
hypot2_(*xs)
Compute the squared norm sum(x**2 for x in
xs). |
|
|
|
hypot3(x,
y,
z)
DEPRECATED, use function hypot_. |
|
|
|
hypot_(*xs)
Compute the norm sqrt(sum(x**2 for x in xs)). |
|
|
|
inStr(inst,
*args,
**kwds)
DEPRECATED, use function instr. |
|
|
|
instr(inst,
*args,
**kwds)
Return the string representation of an instantiation. |
|
|
|
intersections2(center1,
radius1,
center2,
radius2,
sphere=True,
Vector=None,
**Vector_kwds)
Compute the intersection of two spheres or circles, each defined by a
center point and a radius. |
|
|
|
isNumpy2(obj)
Check for an Numpy2LatLon points wrapper. |
|
|
|
isPoints2(obj)
Check for an LatLon2psxy points wrapper. |
|
|
|
isTuple2(obj)
Check for an Tuple2LatLon points wrapper. |
|
|
|
isantipode(lat1,
lon1,
lat2,
lon2,
eps=2.22044604925e-16)
Check whether two points are antipodal, on diametrically opposite
sides of the earth. |
|
|
|
isantipode_(phi1,
lam1,
phi2,
lam2,
eps=2.22044604925e-16)
Check whether two points are antipodal, on diametrically opposite
sides of the earth. |
|
|
|
isclass(obj)
Return True if obj is a
class . |
|
|
|
isclockwise(points,
adjust=False,
wrap=True)
Determine the direction of a path or polygon. |
|
|
|
iscolinearWith(point,
point1,
point2,
eps=2.22044604925e-16)
Check whether a point is colinear with two other points. |
|
|
|
isconvex(points,
adjust=False,
wrap=True)
Determine whether a polygon is convex. |
|
|
|
isconvex_(points,
adjust=False,
wrap=True)
Determine whether a polygon is convex and clockwise. |
|
|
|
isenclosedBy(point,
points,
wrap=False)
Determine whether a point is enclosed by a polygon. |
|
|
|
isenclosedby(point,
points,
wrap=False)
DEPRECATED, use function isenclosedBy. |
|
|
|
isfinite(obj)
Check for Inf and NaN values. |
|
|
|
isidentifier(obj)
Return True if obj is a valid Python
identifier. |
|
|
bool
|
isinf(x)
Check if float x is infinite (positive or negative). |
|
|
|
isint(obj,
both=False)
Check for int type or an integer float
value. |
|
|
|
|
bool
|
isnan(x)
Check if float x is not a number (NaN). |
|
|
|
isneg0(obj)
Check for NEG0, negative 0.0. |
|
|
|
ispolar(points,
wrap=False)
Check whether a polygon encloses a pole. |
|
|
|
|
|
issequence(obj,
*excluded)
Check for sequence types. |
|
|
|
isstr(obj)
Check for string types. |
|
|
|
issubclassof(Sub,
Super)
Check whether a class is a sub-class of a super class. |
|
|
|
iterNumpy2(obj)
Iterate over Numpy2 wrappers or other sequences exceeding the
threshold. |
|
|
|
|
|
joined(*words,
**sep)
Joined words by separator sep=NN . |
|
|
|
joined_(*words,
**sep)
Joined words by separator sep=" " . |
|
|
|
latDMS(deg,
form=' dms ' ,
prec=2,
sep='
' )
Convert latitude to a string, optionally suffixed with N or S. |
|
|
|
latlon2n_xyz(lat,
lon)
Convert lat-, longitude to n-vector (normal to the
earth's surface) X, Y and Z components. |
|
|
|
latlonDMS(lls,
form=' dms ' ,
prec=None,
sep=None)
Convert one or more LatLon instances to strings. |
|
|
|
len2(items)
Make built-in function len work for
generators, iterators, etc. |
|
|
|
|
|
lonDMS(deg,
form=' dms ' ,
prec=2,
sep='
' )
Convert longitude to a string, optionally suffixed with E or W. |
|
|
|
luneOf(lon1,
lon2,
closed=False,
LatLon=<class 'pygeodesy.points.LatLon_'>,
**LatLon_kwds)
Generate an ellipsoidal or spherical lune-shaped path or polygon. |
|
|
|
m2NM(meter)
Convert meter to nautical miles (NM). |
|
|
|
m2SM(meter)
Convert meter to statute miles (SM). |
|
|
|
m2degrees(meter,
radius=6371008.77141,
lat=0)
Convert distance to angle along equator or along a parallel at an
other latitude. |
|
|
|
m2ft(meter,
usurvey=False)
Convert meter to International or US Survey feet
(ft ). |
|
|
|
m2km(meter)
Convert meter to kilo meter (km). |
|
|
|
map1(func,
*xs)
Apply each argument to a single-argument function and return a
tuple of results. |
|
|
|
map2(func,
*xs)
Apply arguments to a function and return a tuple of
results. |
|
|
|
modulename(clas,
prefixed=None)
Return the class name optionally prefixed with the module name. |
|
|
|
n2e2(n)
Return e2 , the eccentricity squared for a given
3rd flattening. |
|
|
|
n2f(n)
Return f , the flattening for a given 3rd
flattening. |
|
|
|
n_xyz2latlon(x,
y,
z)
Convert n-vector components to lat- and longitude in
degrees . |
|
|
|
n_xyz2philam(x,
y,
z)
Convert n-vector components to lat- and longitude in
radians . |
|
|
|
nameof(inst)
Get the name of an instance. |
|
|
|
|
|
|
|
nearestOn5(point,
points,
closed=False,
wrap=False,
LatLon=None,
**options)
Locate the point on a path or polygon closest to an other point. |
|
|
|
normDMS(strDMS,
norm='
' )
Normalize all degree ˚, minute ' and second " symbols in a
string to the default symbols %s, %s and %s. |
|
|
|
notImplemented(inst,
name,
*args,
**kwds)
Raise a NotImplementedError for a missing method or
property. |
|
|
|
notOverloaded(inst,
name,
*args,
**kwds)
Raise an AssertionError for a method or property not
overloaded. |
|
|
|
pairs(items,
prec=6,
fmt=' F ' ,
ints=False,
sep=' = ' )
Convert items to name=value strings, with float s
handled like fstr. |
|
|
|
parse3d(str3d,
sep=' , ' ,
name='
' ,
Vector=<class 'pygeodesy.vector3d.Vector3d'>,
**Vector_kwds)
Parse an "x, y, z" string. |
|
|
|
parse3llh(strllh,
height=0,
sep=' , ' ,
clipLat=90,
clipLon=180)
Parse a string "lat lon [h]" representing
lat-, longitude in degrees and optional height in
meter . |
|
|
|
parseDDDMMSS(strDDDMMSS,
suffix=' NSEW ' ,
sep='
' ,
clip=0)
Parse a lat- or longitude represention form [D]DDMMSS in degrees. |
|
|
|
parseDMS(strDMS,
suffix=' NSEW ' ,
sep='
' ,
clip=0)
Parse a lat- or longitude representation "lat,
lon" in degrees . |
|
|
|
parseDMS2(strLat,
strLon,
sep='
' ,
clipLat=90,
clipLon=180)
Parse a lat- and a longitude representions in degrees . |
|
|
|
parseETM5(strUTM,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Etm=<class 'pygeodesy.etm.Etm'>,
falsed=True,
name='
' )
Parse a string representing a UTM coordinate, consisting of
"zone[band] hemisphere easting northing" . |
|
|
|
parseMGRS(strMGRS,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Mgrs=<class 'pygeodesy.mgrs.Mgrs'>,
name='
' )
Parse a string representing a MGRS grid reference, consisting of
"zoneBand, grid, easting, northing" . |
|
|
|
parseOSGR(strOSGR,
Osgr=<class 'pygeodesy.osgr.Osgr'>,
name='
' )
Parse a string representing an OSGR grid reference, consisting of
"[grid] easting northing" . |
|
|
|
parseRad(strRad,
suffix=' NSEW ' ,
clip=0)
Parse a string representing angle in radians . |
|
|
|
parseUPS5(strUPS,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Ups=<class 'pygeodesy.ups.Ups'>,
falsed=True,
name='
' )
Parse a string representing a UPS coordinate, consisting of
"[zone][band] pole easting northing" where
zone is pseudo zone
"00"|"0"|"" and
band is 'A'|'B'|'Y'|'Z'|'' . |
|
|
|
|
|
parseUTM5(strUTM,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Utm=<class 'pygeodesy.utm.Utm'>,
falsed=True,
name='
' )
Parse a string representing a UTM coordinate, consisting of
"zone[band] hemisphere easting northing" . |
|
|
|
parseUTMUPS5(strUTMUPS,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Utm=<class 'pygeodesy.utm.Utm'>,
Ups=<class 'pygeodesy.ups.Ups'>,
name='
' )
Parse a string representing a UTM or UPS coordinate, consisting of
"zone[band] hemisphere/pole easting northing" . |
|
|
|
parseWM(strWM,
radius=6378137.0,
Wm=<class 'pygeodesy.webmercator.Wm'>,
name='
' )
Parse a string "e n [r]" representing a WM
coordinate, consisting of easting, northing and an optional radius. |
|
|
|
perimeterOf(points,
closed=False,
adjust=True,
radius=6371008.77141,
wrap=True)
Approximate the perimeter of a path or polygon. |
|
|
|
perimeterof(points,
closed=False,
adjust=True,
radius=_R_M,
wrap=True)
DEPRECATED, use function perimeterOf. |
|
|
|
philam2n_xyz(phi,
lam)
Convert lat-, longitude to n-vector (normal to the
earth's surface) X, Y and Z components. |
|
|
|
points2(points,
closed=True,
base=None,
Error=<class 'pygeodesy.errors.PointsError'>)
Check a path or polygon represented by points. |
|
|
|
polygon(points,
closed=True,
base=None)
DEPRECATED, use function points2. |
|
|
|
precision(form,
prec=None)
Set the default precison for a given F_ form. |
|
|
|
|
|
quadOf(lat1,
lon1,
lat2,
lon2,
closed=False,
LatLon=<class 'pygeodesy.points.LatLon_'>,
**LatLon_kwds)
Generate a quadrilateral path or polygon from two points. |
|
|
|
radians(x)
Convert angle x from degrees to radians. |
|
|
|
radiansPI(deg)
Convert and wrap degrees to radians [-PI..+PI]. |
|
|
|
radiansPI2(deg)
Convert and wrap degrees to radians [0..+2PI). |
|
|
|
radiansPI_2(deg)
Convert and wrap degrees to radians [-3PI/2..+PI/2]. |
|
|
|
|
|
|
|
|
|
reprs(objs,
prec=6,
fmt=' F ' ,
ints=False)
Convert objects to repr strings, with
float s handled like fstr. |
|
|
|
scalar(value,
low=2.22044604925e-16,
high=1.0,
name=' scalar ' ,
Error=<type 'exceptions.ValueError'>)
DEPRECATED, use class Number_ or Scalar_. |
|
|
|
simplify1(points,
distance,
radius=6371008.77141,
indices=False,
**options)
Basic simplification of a path of LatLon points. |
|
|
|
simplify2(points,
pipe,
radius=_R_M,
shortest=False,
indices=False,
**options)
DEPRECATED, use function simplifyRW. |
|
|
|
simplifyRDP(points,
distance,
radius=6371008.77141,
shortest=False,
indices=False,
**options)
Ramer-Douglas-Peucker (RDP) simplification of a path of
LatLon points. |
|
|
|
simplifyRDPm(points,
distance,
radius=6371008.77141,
shortest=False,
indices=False,
**options)
Modified Ramer-Douglas-Peucker (RDPm) simplification of a path of
LatLon points. |
|
|
|
simplifyRW(points,
pipe,
radius=6371008.77141,
shortest=False,
indices=False,
**options)
Reumann-Witkam (RW) simplification of a path of LatLon
points. |
|
|
|
simplifyVW(points,
area,
radius=6371008.77141,
attr=None,
indices=False,
**options)
Visvalingam-Whyatt (VW) simplification of a path of
LatLon points. |
|
|
|
simplifyVWm(points,
area,
radius=6371008.77141,
attr=None,
indices=False,
**options)
Modified Visvalingam-Whyatt (VWm) simplification of a path of
LatLon points. |
|
|
|
sincos2(*rad)
Return the sine and cosine of angle(s). |
|
|
|
sincos2d(*deg)
Return the sine and cosine of angle(s) in
degrees . |
|
|
|
splice(iterable,
n=2,
**fill)
Split an iterable into n slices. |
|
|
|
sqrt3(x)
Compute the square root, cubed sqrt(x)**3 or sqrt(x**3). |
|
|
|
strs(objs,
prec=6,
fmt=' F ' ,
ints=False)
Convert objects to str strings, with float s
handled like fstr. |
|
|
|
tanPI_2_2(rad)
Compute the tangent of half angle, 90 degrees rotated. |
|
|
|
tan_2(rad)
Compute the tangent of half angle. |
|
|
|
thomas(lat1,
lon1,
lat2,
lon2,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
wrap=False)
Compute the distance between two (ellipsoidal) points using Thomas' formula. |
|
|
|
thomas_(phi2,
phi1,
lam21,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... )
Compute the angular distance between two (ellipsoidal) points
using Thomas' formula. |
|
|
|
toCss(latlon,
cs0=None,
height=None,
Css=<class 'pygeodesy.css.Css'>,
name='
' )
Convert an (ellipsoidal) geodetic point to a Cassini-Soldner
location. |
|
|
|
toDMS(deg,
form=' dms ' ,
prec=2,
sep='
' ,
ddd=2,
neg=' - ' ,
pos='
' )
Convert signed degrees to string, without suffix. |
|
|
|
toEtm8(latlon,
lon=None,
datum=None,
Etm=<class 'pygeodesy.etm.Etm'>,
falsed=True,
name='
' ,
zone=None,
**cmoff)
Convert a lat-/longitude point to an ETM coordinate. |
|
|
|
toLcc(latlon,
conic=Conic(name='WRF_Lb', lat0=40, lon0=-97, par1=33, par2=45, E0=0... ,
height=None,
Lcc=<class 'pygeodesy.lcc.Lcc'>,
name='
' ,
**Lcc_kwds)
Convert an (ellipsoidal) geodetic point to a Lambert location. |
|
|
|
toMgrs(utm,
Mgrs=<class 'pygeodesy.mgrs.Mgrs'>,
name='
' ,
**Mgrs_kwds)
Convert a UTM coordinate to an MGRS grid reference. |
|
|
|
toOsgr(latlon,
lon=None,
datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran... ,
Osgr=<class 'pygeodesy.osgr.Osgr'>,
name='
' ,
**Osgr_kwds)
Convert a lat-/longitude point to an OSGR coordinate. |
|
|
|
toUps8(latlon,
lon=None,
datum=None,
Ups=<class 'pygeodesy.ups.Ups'>,
pole='
' ,
falsed=True,
strict=True,
name='
' )
Convert a lat-/longitude point to a UPS coordinate. |
|
|
|
toUtm(latlon,
lon=None,
datum=None,
Utm=_R_M,
cmoff=True,
name='
' )
DEPRECATED, use function toUtm8. |
|
|
|
toUtm8(latlon,
lon=None,
datum=None,
Utm=<class 'pygeodesy.utm.Utm'>,
falsed=True,
name='
' ,
zone=None,
**cmoff)
Convert a lat-/longitude point to a UTM coordinate. |
|
|
|
toUtmUps8(latlon,
lon=None,
datum=None,
falsed=True,
Utm=<class 'pygeodesy.utm.Utm'>,
Ups=<class 'pygeodesy.ups.Ups'>,
pole='
' ,
name='
' ,
**cmoff)
Convert a lat-/longitude point to a UTM or UPS coordinate. |
|
|
|
toWm(latlon,
lon=None,
radius=6378137.0,
Wm=<class 'pygeodesy.webmercator.Wm'>,
name='
' ,
**Wm_kwds)
Convert a lat-/longitude point to a WM coordinate. |
|
|
|
trilaterate3d2(center1,
radius1,
center2,
radius2,
center3,
radius3,
eps=2.22044604925e-16,
Vector=None,
**Vector_kwds)
Trilaterate three spheres, each given as a (3d) center point and
radius. |
|
|
|
ub2str(ub)
Convert unicode or bytes to
str . |
|
|
|
unStr(name,
*args,
**kwds)
DEPRECATED, use function unstr. |
|
|
|
unroll180(lon1,
lon2,
wrap=True)
Unroll longitudinal delta and wrap longitude in degrees. |
|
|
|
unrollPI(rad1,
rad2,
wrap=True)
Unroll longitudinal delta and wrap longitude in radians. |
|
|
|
unstr(name,
*args,
**kwds)
Return the string representation of an invokation. |
|
|
|
upsZoneBand5(lat,
lon,
strict=True)
Return the UTM/UPS zone number, (polar) Band letter, pole and clipped
lat- and longitude for a given location. |
|
|
|
|
|
utmZoneBand5(lat,
lon,
cmoff=False)
Return the UTM zone number, Band letter, hemisphere and (clipped)
lat- and longitude for a given location. |
|
|
|
utmupsValidate(coord,
falsed=False,
MGRS=False,
Error=<class 'pygeodesy.utmups.UTMUPSError'>)
Check a UTM or UPS coordinate. |
|
|
|
|
|
utmupsZoneBand5(lat,
lon,
cmoff=False)
Return the UTM/UPS zone number, Band letter, hemisphere/pole and
clipped lat- and longitude for a given location. |
|
|
|
vincentys(lat1,
lon1,
lat2,
lon2,
radius=6371008.77141,
wrap=False)
Compute the distance between two (spherical) points using Vincenty's spherical formula. |
|
|
|
vincentys_(phi2,
phi1,
lam21)
Compute the angular distance between two (spherical) points
using Vincenty's spherical formula. |
|
|
|
wrap180(deg)
Wrap degrees to [-180..+180]. |
|
|
|
wrap360(deg)
Wrap degrees to [0..+360). |
|
|
|
wrap90(deg)
Wrap degrees to [-270..+90]. |
|
|
|
wrapPI(rad)
Wrap radians to [-PI..+PI]. |
|
|
|
wrapPI2(rad)
Wrap radians to [0..+2PI). |
|
|
|
wrapPI_2(rad)
Wrap radians to [-3PI/2..+PI/2]. |
|
|