Package pygeodesy :: Module sphericalTrigonometry :: Class LatLon |
[frames] | no frames]

# Class LatLon

               object --+
                        |
             named._Named --+
                            |
             named._NamedBase --+
                                |
            latlonBase.LatLonBase --+
                                    |
    sphericalBase.LatLonSphericalBase --+
                                        |
                                       LatLon

New point on spherical model earth model.

Example:

    >>> p = LatLon(52.205, 0.119)  # height=0

Instance Methods
alongTrackDistanceTo(self, start, end, radius=6371008.77141, wrap=False) Compute the (signed) distance from the start to the closest point on the great circle path defined by a start and an end point. |
bearingTo(self, other, wrap=False, raiser=False) DEPRECATED, use method `initialBearingTo`. |
crossingParallels(self, other, lat, wrap=False) Return the pair of meridians at which a great circle defined by this and an other point crosses the given latitude. |
crossTrackDistanceTo(self, start, end, radius=6371008.77141, wrap=False) Compute the (signed) distance from this point to the great circle defined by a start and an end point. |
destination(self, distance, bearing, radius=6371008.77141, height=None) Locate the destination from this point after having travelled the given distance on the given initial bearing. |
distanceTo(self, other, radius=6371008.77141, wrap=False) Compute the distance from this to an other point. |
greatCircle(self, bearing) Compute the vector normal to great circle obtained by heading on the given initial bearing from this point. |
initialBearingTo(self, other, wrap=False, raiser=False) Compute the initial bearing (forward azimuth) from this to an other point. |
intermediateTo(self, other, fraction, height=None, wrap=False) Locate the point at given fraction between this and an other point. |
intersection(self, end1, other, end2, height=None, wrap=False) Locate the intersection point of two paths both defined by two points or a start point and bearing from North. |
intersections2(self, rad1, other, rad2, radius=6371008.77141, height=None, wrap=True) Compute the intersection points of two circles each defined by a center point and radius. |
isenclosedBy(self, points) Check whether a (convex) polygon encloses this point. |
isEnclosedBy(self, points) DEPRECATED, use method `isenclosedBy`. |
midpointTo(self, other, height=None, wrap=False) Find the midpoint between this and an other point. |
nearestOn(self, point1, point2, radius=6371008.77141, **options) Locate the point between two points closest and this point. |
nearestOn2(self, points, closed=False, radius=6371008.77141, **options) DEPRECATED, use method sphericalTrigonometry.LatLon.nearestOn3. |
nearestOn3(self, points, closed=False, radius=6371008.77141, **options) Locate the point on a polygon closest to this point. |
toCartesian(self, **Cartesian_datum_kwds) Convert this point to `Karney`-based cartesian (ECEF) coordinates. |
Inherited from `sphericalBase.LatLonSphericalBase`: `__init__`, `bearingTo2`, `finalBearingTo`, `maxLat`, `minLat`, `parse`, `rhumbBearingTo`, `rhumbDestination`, `rhumbDistanceTo`, `rhumbMidpointTo`, `toNvector`, `toWm` Inherited from `latlonBase.LatLonBase`: `__eq__`, `__ne__`, `__str__`, `_distanceTo_`, `antipode`, `bounds`, `boundsOf`, `compassAngle`, `compassAngleTo`, `cosineAndoyerLambertTo`, `cosineForsytheAndoyerLambertTo`, `cosineLawTo`, `equals`, `equals3`, `equirectangularTo`, `euclideanTo`, `flatLocalTo`, `flatPolarTo`, `haversineTo`, `heightStr`, `hubenyTo`, `isantipode`, `isantipodeTo`, `isequalTo`, `isequalTo3`, `latlon2`, `latlon2round`, `latlon_`, `philam2`, `points`, `points2`, `thomasTo`, `to2ab`, `to3llh`, `to3xyz`, `toEcef`, `toStr`, `toVector`, `toVector3d`, `vincentysTo` Inherited from `named._NamedBase`: `__repr__`, `others`, `toRepr` Inherited from `named._Named`: `_dot_`, `attrs`, `classof`, `copy`, `toStr2` Inherited from `object`: `__delattr__`, `__format__`, `__getattribute__`, `__hash__`, `__new__`, `__reduce__`, `__reduce_ex__`, `__setattr__`, `__sizeof__`, `__subclasshook__`

Properties
Inherited from `sphericalBase.LatLonSphericalBase`: `datum` Inherited from `latlonBase.LatLonBase`: `Ecef`, `height`, `isEllipsoidal`, `isSpherical`, `lam`, `lat`, `latlon`, `latlonheight`, `lon`, `phi`, `philam`, `philamheight`, `xyz`, `xyzh` Inherited from `named._Named`: `classname`, `classnaming`, `name`, `named`, `named2` Inherited from `object`: `__class__`

Method Details

### alongTrackDistanceTo (self, start, end, radius=6371008.77141, wrap=False) |
Compute the (signed) distance from the start to the closest point on the great circle path defined by a start and an end point. That is, if a perpendicular is drawn from this point to the great circle path, the along-track distance is the distance from the start point to the point where the perpendicular crosses the path. Arguments: `start` - Start point of great circle path (LatLon). `end` - End point of great circle path (LatLon). `radius` - Mean earth radius (`meter`). `wrap` - Wrap and unroll longitudes (`bool`). Returns: Distance along the great circle path (`meter`, same units as `radius`), positive if after the `start` toward the `end` point of the path or negative if before the `start` point. Raises: `TypeError` - The `start` or `end` point is not LatLon. `ValueError` - Invalid `radius`. Example:
    >>> p = LatLon(53.2611, -0.7972)
    >>> s = LatLon(53.3206, -1.7297)
    >>> e = LatLon(53.1887, 0.1334)
    >>> d = p.alongTrackDistanceTo(s, e)  # 62331.58

### crossingParallels (self, other, lat, wrap=False) |
Return the pair of meridians at which a great circle defined by this and an other point crosses the given latitude. Arguments: `other` - The other point defining great circle (LatLon). `lat` - Latitude at the crossing (`degrees`). `wrap` - Wrap and unroll longitudes (`bool`). Returns: 2-Tuple `(lon1, lon2)`, both in `degrees180` or `None` if the great circle doesn't reach `lat`.

### crossTrackDistanceTo (self, start, end, radius=6371008.77141, wrap=False) |
Compute the (signed) distance from this point to the great circle defined by a start and an end point. Arguments: `start` - Start point of great circle path (LatLon). `end` - End point of great circle path (LatLon). `radius` - Mean earth radius (`meter`). `wrap` - Wrap and unroll longitudes (`bool`). Returns: Distance to great circle (negative if to the left or positive if to the right of the path). Raises: `TypeError` - The `start` or `end` point is not LatLon. `ValueError` - Invalid `radius`. Example:
    >>> p = LatLon(53.2611, -0.7972)
    >>> s = LatLon(53.3206, -1.7297)
    >>> e = LatLon(53.1887, 0.1334)
    >>> d = p.crossTrackDistanceTo(s, e)  # -307.5

### destination (self, distance, bearing, radius=6371008.77141, height=None) |
Locate the destination from this point after having travelled the given distance on the given initial bearing. Arguments: `distance` - Distance travelled (`meter`, same units as `radius`). `bearing` - Bearing from this point (compass `degrees360`). `radius` - Mean earth radius (`meter`). `height` - Optional height at destination (`meter`, same units a `radius`). Returns: Destination point (LatLon). Raises: `ValueError` - Invalid `distance`, `bearing`, `radius` or `height`. Example:
    >>> p1 = LatLon(51.4778, -0.0015)
    >>> p2 = p1.destination(7794, 300.7)
    >>> p2.toStr()  # '51.5135°N, 000.0983°W'
JS name: destinationPoint.

### distanceTo (self, other, radius=6371008.77141, wrap=False) |
Compute the distance from this to an other point. Arguments: `other` - The other point (LatLon). `radius` - Mean earth radius (`meter`). `wrap` - Wrap and unroll longitudes (`bool`). Returns: Distance between this and the `other` point (`meter`, same units as `radius`). Raises: `TypeError` - The `other` point is not LatLon. `ValueError` - Invalid `radius`. Example:
    >>> p1 = LatLon(52.205, 0.119)
    >>> p2 = LatLon(48.857, 2.351);
    >>> d = p1.distanceTo(p2)  # 404300

### greatCircle (self, bearing) |
Compute the vector normal to great circle obtained by heading on the given initial bearing from this point. Direction of vector is such that initial bearing vector b = c × n, where n is an n-vector representing this point. Arguments: `bearing` - Bearing from this point (compass `degrees360`). Returns: Vector representing great circle (Vector3d). Raises: `ValueError` - Invalid `bearing`. Example:
    >>> p = LatLon(53.3206, -1.7297)
    >>> g = p.greatCircle(96.0)
    >>> g.toStr()  # (-0.794, 0.129, 0.594)

### initialBearingTo (self, other, wrap=False, raiser=False) |
Compute the initial bearing (forward azimuth) from this to an other point. Arguments: `other` - The other point (spherical LatLon). `wrap` - Wrap and unroll longitudes (`bool`). `raiser` - Optionally, raise CrossError (`bool`), use `raiser`=`True` for behavior like `sphericalNvector.LatLon.initialBearingTo`. Returns: Initial bearing (compass `degrees360`). Raises: `CrossError` - If this and the `other` point coincide, provided `raiser` is `True` and crosserrors is `True`. `TypeError` - The `other` point is not LatLon. Example:
    >>> p1 = LatLon(52.205, 0.119)
    >>> p2 = LatLon(48.857, 2.351)
    >>> b = p1.initialBearingTo(p2)  # 156.2
JS name: bearingTo.

### intermediateTo (self, other, fraction, height=None, wrap=False) |
Locate the point at given fraction between this and an other point. Arguments: `other` - The other point (LatLon). `fraction` - Fraction between both points (float, between 0.0 for this and 1.0 for the other point). `height` - Optional height, overriding the fractional height (`meter`). `wrap` - Wrap and unroll longitudes (`bool`). Returns: Intermediate point (LatLon). Raises: `TypeError` - The `other` point is not LatLon. `ValueError` - Invalid `fraction` or `height`. Example:
    >>> p1 = LatLon(52.205, 0.119)
    >>> p2 = LatLon(48.857, 2.351)
    >>> p = p1.intermediateTo(p2, 0.25)  # 51.3721°N, 000.7073°E
JS name: intermediatePointTo.

### intersection (self, end1, other, end2, height=None, wrap=False) |
Locate the intersection point of two paths both defined by two points or a start point and bearing from North. Arguments: `end1` - End point of this path (LatLon) or the initial bearing at this point (compass `degrees360`). `other` - Start point of the other path (LatLon). `end2` - End point of the other path (LatLon) or the initial bearing at the other start point (compass `degrees360`). `height` - Optional height for intersection point, overriding the mean height (`meter`). `wrap` - Wrap and unroll longitudes (`bool`). Returns: The intersection point (LatLon). An alternate intersection point might be the antipode to the returned result. Raises: `IntersectionError` - Intersection is ambiguous or infinite or the paths are coincident, colinear or parallel. `TypeError` - If `end1`, `other` or `end2` is not LatLon. `ValueError` - Invalid `height`. Example:
    >>> p = LatLon(51.8853, 0.2545)
    >>> s = LatLon(49.0034, 2.5735)
    >>> i = p.intersection(108.547, s, 32.435)  # '50.9078°N, 004.5084°E'

### intersections2 (self, rad1, other, rad2, radius=6371008.77141, height=None, wrap=True) |
Compute the intersection points of two circles each defined by a center point and radius. Arguments: `rad1` - Radius of the this circle (`meter` or `radians`, see `radius`). `other` - Center of the other circle (LatLon). `rad2` - Radius of the other circle (`meter` or `radians`, see `radius`). `radius` - Mean earth radius (`meter` or `None` if both `rad1` and `rad2` are given in `radians`). `height` - Optional height for the intersection points, overriding the "radical height" at the "radical line" between both centers (`meter`) or `None`. `wrap` - Wrap and unroll longitudes (`bool`). Returns: 2-Tuple of the intersection points, each a LatLon instance. For abutting circles, the intersection points are the same instance. Raises: `IntersectionError` - Concentric, antipodal, invalid or non-intersecting circles. `TypeError` - If `other` is not LatLon. `ValueError` - Invalid `rad1`, `rad2`, `radius` or `height`.

### isenclosedBy (self, points) |
Check whether a (convex) polygon encloses this point. Arguments: `points` - The polygon points (LatLon[]). Returns: `True` if the polygon encloses this point, `False` otherwise. Raises: `PointsError` - Insufficient number of `points`. `TypeError` - Some `points` are not LatLon. `ValueError` - Invalid `points`, non-convex polygon. Example:
    >>> b = LatLon(45,1), LatLon(45,2), LatLon(46,2), LatLon(46,1)
    >>> p = LatLon(45,1, 1.1)
    >>> inside = p.isEnclosedBy(b)  # True

### midpointTo (self, other, height=None, wrap=False) |
Find the midpoint between this and an other point. Arguments: `other` - The other point (LatLon). `height` - Optional height for midpoint, overriding the mean height (`meter`). `wrap` - Wrap and unroll longitudes (`bool`). Returns: Midpoint (LatLon). Raises: `TypeError` - The `other` point is not LatLon. `ValueError` - Invalid `height`. Example:
    >>> p1 = LatLon(52.205, 0.119)
    >>> p2 = LatLon(48.857, 2.351)
    >>> m = p1.midpointTo(p2)  # '50.5363°N, 001.2746°E'

### nearestOn (self, point1, point2, radius=6371008.77141, **options) |
Locate the point between two points closest and this point. Distances are approximated by function equirectangular_, subject to the supplied `options`. Arguments: `point1` - Start point (LatLon). `point2` - End point (LatLon). `radius` - Mean earth radius (`meter`). `options` - Optional keyword arguments for function equirectangular_. Returns: Closest point on the arc (LatLon). Raises: `LimitError` - Lat- and/or longitudinal delta exceeds `limit`, see function equirectangular_. `TypeError` - If `point1` or `point2` is not LatLon. `ValueError` - Invalid `radius`. See Also: Functions equirectangular_ and nearestOn5 and method sphericalTrigonometry.LatLon.nearestOn3.

### nearestOn2 (self, points, closed=False, radius=6371008.77141, **options) |
DEPRECATED, use method sphericalTrigonometry.LatLon.nearestOn3. Returns: ... 2-Tuple `(closest, distance)` of the closest point (LatLon) on the polygon and the distance to that point from this point in `meter`, same units of `radius`.

### nearestOn3 (self, points, closed=False, radius=6371008.77141, **options) |
Locate the point on a polygon closest to this point. Distances are approximated by function equirectangular_, subject to the supplied `options`. Arguments: `points` - The polygon points (LatLon[]). `closed` - Optionally, close the polygon (`bool`). `radius` - Mean earth radius (`meter`). `options` - Optional keyword arguments for function equirectangular_. Returns: A NearestOn3Tuple`(closest, distance, angle)` of the `closest` point (LatLon), the equirectangular_ `distance` between this and the `closest` point in `meter`, same units as `radius`. The `angle` from this to the `closest` point is in compass `degrees360`, like function compassAngle. Raises: `LimitError` - Lat- and/or longitudinal delta exceeds `limit`, see function equirectangular_. `PointsError` - Insufficient number of `points`. `TypeError` - Some `points` are not `LatLon`. `ValueError` - Invalid `radius`. See Also: Functions compassAngle, equirectangular_ and nearestOn5.

### toCartesian (self, **Cartesian_datum_kwds) |
Convert this point to `Karney`-based cartesian (ECEF) coordinates. Arguments: `Cartesian_datum_kwds` - Optional Cartesian, `datum` and other keyword arguments, ignored if `Cartesian=None`. Use `Cartesian=...` to override this Cartesian class or specify `Cartesian=None`. Returns: The cartesian point (Cartesian) or if `Cartesian` is `None`, an Ecef9Tuple`(x, y, z, lat, lon, height, C, M, datum)` with `C` and `M` if available. Raises: `TypeError` - Invalid `Cartesian_datum_kwds`. Overrides: latlonBase.LatLonBase.toCartesian