Package distances

Return the antipode, the point diametrically opposite to a given point in degrees.

Arguments:

• lat - Latitude (degrees).
• lon - Longitude (degrees).
• name - Optional name (str).

Returns:

A LatLon2Tuple(lat, lon).

Return the antipode, the point diametrically opposite to a given point in radians.

Arguments:

• phi - Latitude (radians).
• lam - Longitude (radians).
• name - Optional name (str).

Returns:

A PhiLam2Tuple(phi, lam).

Compute the initial or final bearing (forward or reverse azimuth) between a (spherical) start and end point.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• final_wrap - Optional keyword arguments for function pygeodesy3.bearing_.

Returns:

Initial or final bearing (compass degrees360) or zero if start and end point coincide.

Compute the initial or final bearing (forward or reverse azimuth) between a (spherical) start and end point.

Arguments:

• phi1 - Start latitude (radians).
• lam1 - Start longitude (radians).
• phi2 - End latitude (radians).
• lam2 - End longitude (radians).
• final - Return final bearing if True, initial otherwise (bool).
• wrap - If True, wrap or normalize and unroll phi2 and lam2 (bool).

Returns:

Initial or final bearing (compass radiansPI2) or zero if start and end point coincide.

3-Point resection using Cassini's method.

Arguments:

• pointA - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• pointB - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• pointC - Center point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• alpha - Angle subtended by triangle side pointA to pointC (degrees, non-negative).
• beta - Angle subtended by triangle side pointB to pointC (degrees, non-negative).
• useZ - If True, use and interpolate the Z component, otherwise force z=INT0 (bool).
• Clas - Optional class to return the survey point or None for pointA's (sub-)class.
• Clas_kwds - Optional, additional keyword argument for the survey point instance.

Returns:

The survey point, an instance of Clas or if Clas is None an instance of pointA's (sub-)class.

Raises:

• ResectionError - Near-coincident, -colinear or -concyclic points or negative or invalid alpha or beta.
• TypeError - Invalid pointA, pointB or pointM.

3-Point resection using Collins' method.

Arguments:

• pointA - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• pointB - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• pointC - Center point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• alpha - Angle subtended by triangle side b from pointA to pointC (degrees, non-negative).
• beta - Angle subtended by triangle side a from pointB to pointC (degrees, non-negative).
• useZ - If True, use and interpolate the Z component, otherwise force z=INT0 (bool).
• Clas - Optional class to return the survey and auxiliary point or None for pointA's (sub-)class.
• Clas_kwds - Optional, additional keyword argument for the survey and auxiliary point instance.

Returns:

Collins5Tuple(pointP, pointH, a, b, c) with survey pointP, auxiliary pointH, each an instance of Clas or if Clas is None an instance of pointA's (sub-)class and triangle sides a, b and c in meter, conventionally.

Raises:

• ResectionError - Near-coincident, -colinear or -concyclic points or negative or invalid alpha or beta.
• TypeError - Invalid pointA, pointB or pointM.

Return the angle from North for the direction vector (lon2 - lon1, lat2 - lat1) between two points.

Suitable only for short, not near-polar vectors up to a few hundred Km or Miles. Use function pygeodesy3.bearing for longer vectors.

Arguments:

• lat1 - From latitude (degrees).
• lon1 - From longitude (degrees).
• lat2 - To latitude (degrees).
• lon2 - To longitude (degrees).
• adjust - Adjust the longitudinal delta by the cosine of the mean latitude (bool).
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Compass angle from North (degrees360).

Compute the distance between two (ellipsoidal) points using the Andoyer-Lambert correction of the Law of Cosines formula.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• datum - Datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Distance (meter, same units as the datum's ellipsoid axes or radians if datum is None).

Raises:

• TypeError - Invalid datum.

Compute the angular distance between two (ellipsoidal) points using the Andoyer-Lambert correction of the Law of Cosines formula.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).
• datum - Datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.

Returns:

Angular distance (radians).

Raises:

• TypeError - Invalid datum.

Compute the distance between two (ellipsoidal) points using the Forsythe-Andoyer-Lambert correction of the Law of Cosines formula.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• datum - Datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Distance (meter, same units as the datum's ellipsoid axes or radians if datum is None).

Raises:

• TypeError - Invalid datum.

Compute the angular distance between two (ellipsoidal) points using the Forsythe-Andoyer-Lambert correction of the Law of Cosines formula.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).
• datum - Datum (Datum) or ellipsoid to use (Ellipsoid, Ellipsoid2 or a_f2Tuple).

Returns:

Angular distance (radians).

Raises:

• TypeError - Invalid datum.

Compute the distance between two points using the spherical Law of Cosines formula.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• radius - Mean earth radius (meter), datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• wrap - If True, wrap or normalize and lat2 and lon2 (bool).

Returns:

Distance (meter, same units as radius or the ellipsoid or datum axes).

Raises:

• TypeError - Invalid radius.

Compute the angular distance between two points using the spherical Law of Cosines formula.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).

Returns:

Angular distance (radians).

Compute the distance between two points using the Equirectangular Approximation / Projection.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• radius - Mean earth radius (meter), datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple).
• adjust_limit_wrap - Optional keyword arguments for function equirectangular_.

Returns:

Distance (meter, same units as radius or the ellipsoid or datum axes).

Raises:

• TypeError - Invalid radius.

Compute the distance between two points using the Equirectangular Approximation / Projection.

This approximation is valid for short distance of several hundred Km or Miles, see the limit keyword argument and LimitError.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• adjust - Adjust the wrapped, unrolled longitudinal delta by the cosine of the mean latitude (bool).
• limit - Optional limit for lat- and longitudinal deltas (degrees) or None or 0 for unlimited.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

A Distance4Tuple(distance2, delta_lat, delta_lon, unroll_lon2) in degrees squared.

Raises:

• LimitError - If the lat- and/or longitudinal delta exceeds the -limit..limit range and pygeodesy3.limiterrors set to True.

Approximate the Euclidean distance between two (spherical) points.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• radius - Mean earth radius (meter), datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• adjust - Adjust the longitudinal delta by the cosine of the mean latitude (bool).
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Distance (meter, same units as radius or the ellipsoid or datum axes).

Raises:

• TypeError - Invalid radius.

Approximate the angular Euclidean distance between two (spherical) points.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).
• adjust - Adjust the longitudinal delta by the cosine of the mean latitude (bool).

Returns:

Angular distance (radians).

Compute the spherical excess E of a (spherical) triangle from two sides and the included (small) angle.

Arguments:

• A - An interior triangle angle (radians).
• b - Frist adjacent triangle side (radians).
• c - Second adjacent triangle side (radians).

Returns:

Spherical excess (radians).

Raises:

• UnitError - Invalid A, b or c.

Compute the spherical excess E of a (spherical) triangle using Cagnoli's (D.34) formula.

Arguments:

• a - First triangle side (radians).
• b - Second triangle side (radians).
• c - Third triangle side (radians).

Returns:

Spherical excess (radians).

Raises:

• UnitError - Invalid a, b or c.

Compute the spherical excess E of a (spherical) triangle using Girard's formula.

Arguments:

• A - First interior triangle angle (radians).
• B - Second interior triangle angle (radians).
• C - Third interior triangle angle (radians).

Returns:

Spherical excess (radians).

Raises:

• UnitError - Invalid A, B or C.

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.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• radius - Mean earth radius (meter), datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) or None.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Surface area, signed (square meter or the same units as radius squared) or the spherical excess (radians) if radius=0 or None.

Raises:

• TypeError - Invalid radius.
• UnitError - Invalid lat2 or lat1.
• ValueError - Semi-circular longitudinal delta.

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.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).

Returns:

Spherical excess, signed (radians).

Raises:

• ValueError - Semi-circular longitudinal delta lam21.

Compute the spherical excess E of a (spherical) triangle using L'Huilier's's Theorem.

Arguments:

• a - First triangle side (radians).
• b - Second triangle side (radians).
• c - Third triangle side (radians).

Returns:

Spherical excess (radians).

Raises:

• UnitError - Invalid a, b or c.

Compute the surface area of a (spherical) quadrilateral bounded by a segment of a great circle, two meridians and the equator.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• radius - Mean earth radius (meter), datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) or None.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Surface area, signed (square meter or the same units as radius squared) or the spherical excess (radians) if radius=0 or None.

Raises:

• TypeError - Invalid radius.
• UnitError - Invalid lat2 or lat1.

Compute the spherical excess E of a (spherical) quadrilateral bounded by a segment of a great circle, two meridians and the equator.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).

Returns:

Spherical excess, signed (radians).

Compute the distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• datum - Datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• scaled - Scale prime_vertical by cos(phi) (bool), see method pygeodesy3.Ellipsoid.roc2_.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Distance (meter, same units as the datum's ellipsoid axes).

Raises:

• TypeError - Invalid datum.

Compute the angular distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).
• datum - Datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• scaled - Scale prime_vertical by cos(phi) (bool), see method pygeodesy3.Ellipsoid.roc2_.

Returns:

Angular distance (radians).

Raises:

• TypeError - Invalid datum.

Compute the distance between two (spherical) points using the polar coordinate flat-Earth formula.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• radius - Mean earth radius (meter), datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• wrap - If True, wrap or normalize and lat2 and lon2 (bool).

Returns:

Distance (meter, same units as radius or the ellipsoid or datum axes).

Raises:

• TypeError - Invalid radius.

Compute the angular distance between two (spherical) points using the polar coordinate flat-Earth formula.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).

Returns:

Angular distance (radians).

Compute the discrete Fréchet distance between two paths, each given as a set of points.

Arguments:

• point1s - First set of points (LatLon[], Numpy2LatLon[], Tuple2LatLon[] or other[]).
• point2s - Second set of points (LatLon[], Numpy2LatLon[], Tuple2LatLon[] or other[]).
• distance - Callable returning the distance between a point1s and a point2s point (signature (point1, point2)).
• units - Optional, the distance units (Unit or str).

Returns:

A Frechet6Tuple(fd, fi1, fi2, r, n, units) where fi1 and fi2 are type int indices into point1s respectively point2s.

Raises:

• FrechetError - Insufficient number of point1s or point2s.
• RecursionError - Recursion depth exceeded, see sys.getrecursionlimit().
• TypeError - If distance is not a callable.

Compute the intersection of the earth's surface and a Line-Of-Sight from a Point-Of-View in space.

Arguments:

• pov - Point-Of-View outside the earth (LatLon, Cartesian, Ecef9Tuple or Vector3d).
• los - Line-Of-Sight, direction to earth (Los, Vector3d), True for the normal, plumb onto the surface or False or None to point to the center of the earth.
• earth - The earth model (Datum, Ellipsoid, Ellipsoid2, a_f2Tuple or a scalar earth radius in meter).
• name - Optional name (str).
• LatLon_and_kwds - Optional LatLon=None class to return the intersection plus additional LatLon keyword arguments, include datum if different from earth.

Returns:

The intersection (Vector3d, pov's cartesian type or the given LatLon instance) with attribute heigth set to the distance to the pov.

Raises:

• IntersectionError - Invalid pov or pov inside the earth or invalid los or los points outside or away from the earth.
• TypeError - Invalid earth or datum.

Compute the directed or symmetric Hausdorff distance between 2 sets of points with or without early breaking and random sampling.

Arguments:

• model - First set of points (LatLon[], Numpy2LatLon[], Tuple2LatLon[] or other[]).
• target - Second set of points (LatLon[], Numpy2LatLon[], Tuple2LatLon[] or other[]).
• both - Return the directed (forward only) or the symmetric (combined forward and reverse) Hausdorff distance (bool).
• early - Enable or disable early breaking (bool).
• seed - Random sampling seed (any) or None, 0 or False for no random sampling.
• units - Optional, the distance units (Unit or str).
• distance - Callable returning the distance between a model and target point (signature (point1, point2)).
• point - Callable returning the model or target point suitable for distance (signature (point)).

Returns:

A Hausdorff6Tuple(hd, i, j, mn, md, units).

Raises:

• HausdorffError - Insufficient number of model or target points.
• TypeError - If distance or point is not callable.

Compute the distance between two (spherical) points using the Haversine formula.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• radius - Mean earth radius (meter), datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Distance (meter, same units as radius).

Raises:

• TypeError - Invalid radius.

Compute the angular distance between two (spherical) points using the Haversine formula.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).

Returns:

Angular distance (radians).

Determine the height above the (spherical) earth' surface after traveling along a straight line at a given tilt.

Arguments:

• angle - Tilt angle above horizontal (degrees).
• distance - Distance along the line (meter or same units as radius).
• radius - Optional mean earth radius (meter).

Returns:

Height (meter, same units as distance and radius).

Raises:

• ValueError - Invalid angle, distance or radius.

Get the orthometric height H, the height above the geoid, earth surface.

Arguments:

• h_ll - The height above the ellipsoid (meter) or an ellipsoidal location (LatLon with a height or h attribute).
• N - The geoid height (meter), the height of the geoid above the ellipsoid at the same h_ll location.

Returns:

Orthometric height H = h - N (meter, same units as h and N).

Determine the distance to the horizon from a given altitude above the (spherical) earth.

Arguments:

• height - Altitude (meter or same units as radius).
• radius - Optional mean earth radius (meter).
• refraction - Consider atmospheric refraction (bool).

Returns:

Distance (meter, same units as height and radius).

Raises:

• ValueError - Invalid height or radius.

Compute the distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• datum - Datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• scaled - Scale prime_vertical by cos(phi) (bool), see method pygeodesy3.Ellipsoid.roc2_.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Distance (meter, same units as the datum's ellipsoid axes).

Raises:

• TypeError - Invalid datum.

Compute the angular distance between two (ellipsoidal) points using the ellipsoidal Earth to plane projection aka Hubeny formula.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).
• datum - Datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• scaled - Scale prime_vertical by cos(phi) (bool), see method pygeodesy3.Ellipsoid.roc2_.

Returns:

Angular distance (radians).

Raises:

• TypeError - Invalid datum.

Conveniently compute the intersection of two lines each defined by a (geodetic) point and a bearing from North, using either ...

1) vector3d.intersection3d3 for small distances (below 100 Km or about 0.88 degrees) or if no datum is specified, or ...

2) spherical.trigonometry.intersection for a spherical datum or a scalar datum representing the earth radius, conventionally in meter or ...

3) spherical.nvector.intersection if datum is a negative scalar, (negative) earth radius, conventionally in meter or ...

4) ellipsoidal.karney.intersection3 for an ellipsoidal datum and if Karney's geographiclib is installed, otherwise ...

5) ellipsoidal.exact.intersection3, provided datum is ellipsoidal.

Arguments:

• lat1 - Latitude of the first point (degrees).
• lon1 - Longitude of the first point (degrees).
• bearing1 - Bearing at the first point (compass degrees).
• lat2 - Latitude of the second point (degrees).
• lon2 - Longitude of the second point (degrees).
• bearing2 - Bearing at the second point (compass degrees).
• datum - Optional datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) or scalar earth radius (meter, same units as radius1 and radius2) or None.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).
• small - Upper limit for small distances (meter).

Returns:

A LatLon2Tuple(lat, lon) with the lat- and longitude of the intersection point.

Raises:

• IntersectionError - Ambiguous or infinite intersection or colinear, parallel or otherwise non-intersecting lines.
• TypeError - Invalid datum.
• UnitError - Invalid lat1, lon1, bearing1, lat2, lon2 or bearing2.

Conveniently compute the intersections of two circles each defined by a (geodetic) center point and a radius, using either ...

1) vector3d.intersections2 for small distances (below 100 Km or about 0.88 degrees) or if no datum is specified, or ...

2) spherical.trigonometry.intersections2 for a spherical datum or a scalar datum representing the earth radius, conventionally in meter or ...

3) ellipsoidal.karney.intersections2 for an ellipsoidal datum and if Karney's geographiclib is installed, otherwise ...

4) ellipsoidal.exact.intersections2, provided datum is ellipsoidal.

Arguments:

• lat1 - Latitude of the first circle center (degrees).
• lon1 - Longitude of the first circle center (degrees).
• radius1 - Radius of the first circle (meter, conventionally).
• lat2 - Latitude of the second circle center (degrees).
• lon2 - Longitude of the second circle center (degrees).
• radius2 - Radius of the second circle (meter, same units as radius1).
• datum - Optional datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) or scalar earth radius (meter, same units as radius1 and radius2) or None.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).
• small - Upper limit for small distances (meter).

Returns:

2-Tuple of the intersection points, each a LatLon2Tuple(lat, lon). For abutting circles, the points are the same instance, aka the radical center.

Raises:

• IntersectionError - Concentric, antipodal, invalid or non-intersecting circles or no convergence.
• TypeError - Invalid datum.
• UnitError - Invalid lat1, lon1, radius1, lat2, lon2 or radius2.

Check whether two points are antipodal, on diametrically opposite sides of the earth.

Arguments:

• lat1 - Latitude of one point (degrees).
• lon1 - Longitude of one point (degrees).
• lat2 - Latitude of the other point (degrees).
• lon2 - Longitude of the other point (degrees).
• eps - Tolerance for near-equality (degrees).

Returns:

True if points are antipodal within the eps tolerance, False otherwise.

Check whether two points are antipodal, on diametrically opposite sides of the earth.

Arguments:

• phi1 - Latitude of one point (radians).
• lam1 - Longitude of one point (radians).
• phi2 - Latitude of the other point (radians).
• lam2 - Longitude of the other point (radians).
• eps - Tolerance for near-equality (radians).

Returns:

True if points are antipodal within the eps tolerance, False otherwise.

Check whether lat and lon are within their respective normal range in degrees.

Arguments:

• lat - Latitude (degrees).
• lon - Longitude (degrees).
• eps - Optional tolerance degrees).

Returns:

True if (abs(lat) + eps) <= 90 and (abs(lon) + eps) <= 180, False othwerwise.

Check whether phi and lam are within their respective normal range in radians.

Arguments:

• phi - Latitude (radians).
• lam - Longitude (radians).
• eps - Optional tolerance radians).

Returns:

True if (abs(phi) + eps) <= PI/2 and (abs(lam) + eps) <= PI, False othwerwise.

Convert lat-, longitude to n-vector (normal to the earth's surface) X, Y and Z components.

Arguments:

• lat - Latitude (degrees).
• lon - Longitude (degrees).
• name - Optional name (str).

Returns:

A Vector3Tuple(x, y, z).

Convert n-vector components to lat- and longitude in degrees.

Arguments:

• x - X component (scalar).
• y - Y component (scalar).
• z - Z component (scalar).
• name - Optional name (str).

Returns:

A LatLon2Tuple(lat, lon).

Convert n-vector components to lat- and longitude in radians.

Arguments:

• x - X component (scalar).
• y - Y component (scalar).
• z - Z component (scalar).
• name - Optional name (str).

Returns:

A PhiLam2Tuple(phi, lam).

Normalize a lat- and longitude pair in degrees.

Arguments:

• lat - Latitude (degrees).
• lon - Longitude (degrees).
• name - Optional name (str).

Returns:

LatLon2Tuple(lat, lon) with abs(lat) <= 90 and abs(lon) <= 180.

Normalize a lat- and longitude pair in radians.

Arguments:

• phi - Latitude (radians).
• lam - Longitude (radians).
• name - Optional name (str).

Returns:

PhiLam2Tuple(phi, lam) with abs(phi) <= PI/2 and abs(lam) <= PI.

Compare the direction of two bearings given in degrees.

Arguments:

• bearing1 - First bearing (compass degrees).
• bearing2 - Second bearing (compass degrees).
• margin - Optional, interior angle bracket (degrees).

Returns:

True if both bearings point in opposite, False if in similar or None if in perpendicular directions.

Compare the direction of two bearings given in radians.

Arguments:

• radians1 - First bearing (radians).
• radians2 - Second bearing (radians).
• margin - Optional, interior angle bracket (radians).

Returns:

True if both bearings point in opposite, False if in similar or None if in perpendicular directions.

Convert lat-, longitude to n-vector (normal to the earth's surface) X, Y and Z components.

Arguments:

• phi - Latitude (radians).
• lam - Longitude (radians).
• name - Optional name (str).

Returns:

A Vector3Tuple(x, y, z).

3-Point resection using Pierlot's method ToTal with approximate limits for the (pseudo-)singularities.

Arguments:

• point1 - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• point2 - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• point3 - Third point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• alpha12 - Angle subtended from point1 to point2 or alpha2 - alpha1 (degrees).
• alpha23 - Angle subtended from point2 to point3 or alpha3 - alpha2(degrees).
• useZ - If True, interpolate the survey point's Z component, otherwise use z=INT0 (bool).
• eps - Tolerance for cot (pseudo-)singularities (float).
• Clas - Optional class to return the survey point, if None use point1's (sub-)class.
• Clas_kwds - Optional, additional keyword arguments for the survey point instance.

Returns:

The survey (or robot) point, an instance of Clas or if Clas is None an instance of point1's (sub-)class.

Raises:

• ResectionError - Near-coincident, -colinear or -concyclic points or invalid alpha12 or alpha23 or non-positive eps.
• TypeError - Invalid point1, point2 or point3.

3-Point resection using Pierlot's method ToTal with exact limits for the (pseudo-)singularities.

Arguments:

• point1 - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• point2 - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• point3 - Third point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• alpha1 - Angle at point1 (degrees, counter-clockwise).
• alpha2 - Angle at point2 (degrees, counter-clockwise).
• alpha3 - Angle at point3 (degrees, counter-clockwise).
• useZ - If True, interpolate the survey point's Z component, otherwise use z=INT0 (bool).
• Clas - Optional class to return the survey point, if None use point1's (sub-)class.
• Clas_kwds - Optional, additional keyword arguments for the survey point instance.

Returns:

The survey (or robot) point, an instance of Clas or if Clas is None an instance of point1's (sub-)class.

Raises:

• ResectionError - Near-coincident, -colinear or -concyclic points or invalid alpha1, alpha2 or alpha3.
• TypeError - Invalid point1, point2 or point3.

Compute the radical ratio and radical line of two intersecting circles.

The radical line is perpendicular to the axis thru the centers of the circles at (0, 0) and (distance, 0).

Arguments:

• distance - Distance between the circle centers (scalar).
• radius1 - Radius of the first circle (scalar).
• radius2 - Radius of the second circle (scalar).

Returns:

A Radical2Tuple(ratio, xline) where 0.0 <= ratio <= 1.0 and xline is along the distance.

Raises:

• IntersectionError - The distance exceeds the sum of radius1 and radius2.
• UnitError - Invalid distance, radius1 or radius2.

Return a seeded random range function generator.

Arguments:

• seed - Initial, internal Random state (hashable or None).

Returns:

A function to generate random ranges.

>>> rrange = randomrangenerator('R')
>>> for r in rrange(n):
>>>    ...  # r is random in 0..n-1

Snellius' surveying using Snellius Pothenot.

Arguments:

• a - Length of the triangle side between corners B and C and opposite of triangle corner A (scalar, non-negative meter, conventionally).
• b - Length of the triangle side between corners C and A and opposite of triangle corner B (scalar, non-negative meter, conventionally).
• degC - Angle at triangle corner C, opposite triangle side c (non-negative degrees).
• alpha - Angle subtended by triangle side b (non-negative degrees).
• beta - Angle subtended by triangle side a (non-negative degrees).

Returns:

Survey3Tuple(PA, PB, PC) with distance from survey point P to each of the triangle corners A, B and C, same units as triangle sides a, b and c.

Raises:

• TriangleError - Invalid a, b or degC or negative alpha or beta.

Compute the distance between two (ellipsoidal) points using Thomas' formula.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• datum - Datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Distance (meter, same units as the datum's ellipsoid axes).

Raises:

• TypeError - Invalid datum.

Compute the angular distance between two (ellipsoidal) points using Thomas' formula.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).
• datum - Datum or ellipsoid to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple).

Returns:

Angular distance (radians).

Raises:

• TypeError - Invalid datum.

3-Point resection using Tienstra's formula.

Arguments:

• pointA - First point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• pointB - Second point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• pointC - Third point (Cartesian, Vector3d, Vector3Tuple, Vector4Tuple or Vector2Tuple if useZ=False).
• alpha - Angle subtended by triangle side a from pointB to pointC (degrees, non-negative).
• beta - Angle subtended by triangle side b from pointA to pointC (degrees, non-negative) or None if gamma is not None.
• gamma - Angle subtended by triangle side c from pointA to pointB (degrees, non-negative) or None if beta is not None.
• useZ - If True, use and interpolate the Z component, otherwise force z=INT0 (bool).
• Clas - Optional class to return the survey point or None for pointA's (sub-)class.
• Clas_kwds - Optional, additional keyword arguments for the survey point instance.

Returns:

Tienstra7Tuple(pointP, A, B, C, a, b, c) with survey pointP, an instance of Clas or if Clas is None an instance of pointA's (sub-)class, with triangle angles A at pointA, B at pointB and C at pointC in degrees and with triangle sides a, b and c in meter, conventionally.

Raises:

• ResectionError - Near-coincident, -colinear or -concyclic points or sum of alpha, beta and gamma not 360 or negative alpha, beta or gamma.
• TypeError - Invalid pointA, pointB or pointC.

Compute one angle of a triangle.

Arguments:

• a - Adjacent triangle side length (scalar, non-negative meter, conventionally).
• b - Adjacent triangle side length (scalar, non-negative meter, conventionally).
• c - Opposite triangle side length (scalar, non-negative meter, conventionally).

Returns:

Angle in radians at triangle corner C, opposite triangle side c.

Raises:

• TriangleError - Invalid or negative a, b or c.

Compute the angles of a triangle.

Arguments:

• a - Length of the triangle side opposite of triangle corner A (scalar, non-negative meter, conventionally).
• b - Length of the triangle side opposite of triangle corner B (scalar, non-negative meter, conventionally).
• c - Length of the triangle side opposite of triangle corner C (scalar, non-negative meter, conventionally).

Returns:

TriAngle5Tuple(radA, radB, radC, rIn, area) with angles radA, radB and radC at triangle corners A, B and C, all in radians, the InCircle radius rIn aka inradius, same units as triangle sides a, b and c and the triangle area in those same units squared.

Raises:

• TriangleError - Invalid or negative a, b or c.

Compute the area of a triangle using Heron's stable formula.

Arguments:

• a - Length of the triangle side opposite of triangle corner A (scalar, non-negative meter, conventionally).
• b - Length of the triangle side opposite of triangle corner B (scalar, non-negative meter, conventionally).
• c - Length of the triangle side opposite of triangle corner C (scalar, non-negative meter, conventionally).

Returns:

The triangle area (float, conventionally meter or same units as a, b and c squared).

Raises:

• TriangleError - Invalid or negative a, b or c.

Compute one side of a triangle.

Arguments:

• a - Adjacent triangle side length (scalar, non-negative meter, conventionally).
• b - Adjacent triangle side length (scalar, non-negative meter, conventionally).
• radC - Angle included by sides a and b, opposite triangle side c (radians).

Returns:

Length of triangle side c, opposite triangle corner C and angle radC, same units as a and b.

Raises:

• TriangleError - Invalid a, b or radC.

Compute a side and its opposite angle of a triangle.

Arguments:

• b - Adjacent triangle side length (scalar, non-negative meter, conventionally).
• c - Adjacent triangle side length (scalar, non-negative meter, conventionally).
• radB - Angle included by sides a and c, opposite triangle side b (radians).

Returns:

TriSide2Tuple(a, radA) with triangle angle radA in radians and length of the opposite triangle side a, same units as b and c.

Raises:

• TriangleError - Invalid b or c or either b or radB near zero.

Compute two sides and the height of a triangle.

Arguments:

• radA - Angle at triangle corner A, opposite triangle side a (non-negative radians).
• radB - Angle at triangle corner B, opposite triangle side b (non-negative radians).
• c - Length of triangle side between triangle corners A and B, (scalar, non-negative meter, conventionally).

Returns:

TriSide4Tuple(a, b, radC, d) with triangle sides a and b and triangle height d perpendicular to triangle side c, all in the same units as c and interior angle radC in radians at triangle corner C, opposite triangle side c.

Raises:

• TriangleError - Invalid or negative radA, radB or c.

Compute the distance between two (spherical) points using Vincenty's spherical formula.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• radius - Mean earth radius (meter), datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Distance (meter, same units as radius).

Raises:

• UnitError - Invalid radius.

Compute the angular distance between two (spherical) points using Vincenty's spherical formula.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).

Returns:

Angular distance (radians).

Snellius' surveying using Rational Trigonometry.

Arguments:

• a - Length of the triangle side between corners B and C and opposite of triangle corner A (scalar, non-negative meter, conventionally).
• b - Length of the triangle side between corners C and A and opposite of triangle corner B (scalar, non-negative meter, conventionally).
• c - Length of the triangle side between corners A and B and opposite of triangle corner C (scalar, non-negative meter, conventionally).
• alpha - Angle subtended by triangle side b (degrees, non-negative).
• beta - Angle subtended by triangle side a (degrees, non-negative).
• R3 - Callable to determine R3 from (R3 - C)**2 = D, typically standard Python function min or max, invoked with 2 arguments.

Returns:

Survey3Tuple(PA, PB, PC) with distance from survey point P to each of the triangle corners A, B and C, same units as a, b and c.

Raises:

• TriangleError - Invalid a, b or c or negative alpha or beta or R3 not callable.