Module formy

Get the chord length of a (central) angle or angular distance.

Arguments:

• rad - Central angle (radians).
• radius - Mean earth radius (meter, conventionally), datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use or None.

Returns:

Chord length (meter, same units as radius or if radius is None, radians).

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

Arguments:

• lat - Latitude (degrees).
• lon - Longitude (degrees).
• name - Optional name=NN (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=NN (str).

Returns:

A PhiLam2Tuple(phi, lam).

Compute the initial or final bearing (forward or reverse azimuth) between two (spherical) points.

Arguments:

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

Returns:

Initial or final bearing (compass degrees360) or zero if both points coincide.

Compute the initial or final bearing (forward or reverse azimuth) between two (spherical) points.

Arguments:

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

Returns:

Initial or final bearing (compass radiansPI2) or zero if both points coincide.

Get the (central) angle from a chord length or distance.

Arguments:

• chord - Length or distance (meter, same units as radius).
• radius - Mean earth radius (meter, conventionally), datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.

Returns:

Angle (radians with sign of chord) or 0 if radius=0.

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 pygeodesy.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 points using the Law of Cosines formula, optionally corrected.

Arguments:

• lat1 - Start latitude (degrees).
• lon1 - Start longitude (degrees).
• lat2 - End latitude (degrees).
• lon2 - End longitude (degrees).
• corr - Use corr=2 to apply the Forsythe-Andoyer-Lambert, corr=1 for the Andoyer-Lambert corrected (ellipsoidal) or keep corr=0 for the uncorrected (spherical) Law of Cosines formula (int).
• earth - Mean earth radius (meter) or datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• wrap - If True, wrap or normalize and lat2 and lon2 (bool).
• datum - Default ellipsiodal earth (and for backward compatibility).
• radius - Default spherical earth (and for backward compatibility).

Returns:

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

Raises:

• TypeError - Invalid earth, datum or radius.
• ValueError - Invalid corr.

Compute the angular distance between two points using the Law of Cosines formula, optionally corrected.

Arguments:

• phi2 - End latitude (radians).
• phi1 - Start latitude (radians).
• lam21 - Longitudinal delta, end-start (radians).
• corr - Use corr=2 to apply the Forsythe-Andoyer-Lambert, corr=1 for the Andoyer-Lambert corrected (ellipsoidal) or keep corr=0 for the uncorrected (spherical) Law of Cosines formula (int).
• earth - Mean earth radius (meter) or datum (Datum) or ellipsoid (Ellipsoid, Ellipsoid2 or a_f2Tuple) to use.
• datum - Default ellipsoidal earth (and for backward compatibility).

Returns:

Angular distance (radians).

Raises:

• TypeError - Invalid earth or datum.
• ValueError - Invalid corr.

Approximate 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 - Optionally, keyword arguments for function equirectangular4.

Returns:

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

Raises:

• TypeError - Invalid radius.

Approximate 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) with distance2 in degrees squared.

Raises:

• LimitError - The lat- or longitudinal delta exceeds the -limit..limit range and limiterrors is 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 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 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 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 pygeodesy.Ellipsoid.roc2_.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

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

Raises:

• TypeError - Invalid datum.

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 pygeodesy.Ellipsoid.roc2_.
• wrap - If True, wrap or normalize and unroll lat2 and lon2 (bool).

Returns:

Distance (meter, same units as the datum's or 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 pygeodesy.Ellipsoid.roc2_.

Returns:

Angular distance (radians).

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 pygeodesy.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 datum's or ellipsoid 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 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_LatLon_and_kwds - Optional name="hartzell" (str), class LatLon=None to return the intersection and optionally, additional LatLon keyword arguments, include the datum if different from and to convert from earth.

Returns:

The intersection (Vector3d, pov's cartesian type or the given LatLon instance) with attribute height 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, ellipsoid or datum.

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_loc - The height above the ellipsoid (meter) or an ellipsoidal location (LatLon or Cartesian with a height or h attribute), otherwise 0 meter.
• N - The geoid height (meter), the height of the geoid above the ellipsoid at the same h_loc 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.

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) sphericalTrigonometry.intersection for a spherical datum or a scalar datum representing the earth radius, conventionally in meter or ...

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

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

5) ellipsoidalExact.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 degrees360).
• lat2 - Latitude of the second point (degrees).
• lon2 - Longitude of the second point (degrees).
• bearing2 - Bearing at the second point (compass degrees360).
• 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:

Intersection point (LatLon2Tuple(lat, lon)).

Raises:

• IntersectionError - No or an ambiguous 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) sphericalTrigonometry.intersections2 for a spherical datum or a scalar datum representing the earth radius, conventionally in meter or ...

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

4) ellipsoidalExact.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). Both points are the same instance, aka the radical center if the circles are abutting

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 otherwise.

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.

Normalize a lat- and longitude pair in degrees.

Arguments:

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

Returns:

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

Normalize a lat- and longitude pair in radians.

Arguments:

• phi - Latitude (radians).
• lam - Longitude (radians).
• name - Optional name="normal_" (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.

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).
• name - Optional name=NN (str).

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.

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 or 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 (Datum) ?or ellipsoid to use (Ellipsoid, Ellipsoid2 or a_f2Tuple).

Returns:

Angular distance (radians).

Raises:

• TypeError - Invalid datum.

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).