Package pygeodesy :: Module latlonBase :: Class LatLonBase |
[frames] | no frames]

# Class LatLonBase

      object --+
               |
    named._Named --+
                   |
    named._NamedBase --+
                       |
                      LatLonBase

Known Subclasses:
  - points.LatLon_
  - , ellipsoidalBase.LatLonEllipsoidalBase
  - , nvectorBase.LatLonNvectorBase
  - , sphericalBase.LatLonSphericalBase
  - , deprecated.bases.LatLonHeightBase

(INTERNAL) Base class for `LatLon` points on spherical or ellipsoidal earth models.

Instance Methods
PointsIter(self, points, loop=0, dedup=False, wrap=False) Return a `PointsIter` iterator. |
__eq__(self, other) |
__init__(self, latlonh, lon=None, height=0, datum=None, **wrap_name) New `LatLon`. |
__ne__(self, other) |
__str__(self) Default `str(self)`. |
antipode(self, height=None) Return the antipode, the point diametrically opposite to this point. |
bounds(self, wide, tall, radius=6371008.771415) DEPRECATED, use method `boundsOf`. |
boundsOf(self, wide, tall, radius=6371008.771415, height=None, **name) Return the SW and NE lat-/longitude of a great circle bounding box centered at this location. |
chordTo(self, other, height=None, wrap=False) Compute the length of the chord through the earth between this and an other point. |
circin6(self, point2, point3, eps=8.881784197001252e-16, **wrap_name) Return the radius and center of the inscribed aka In-circle of the (planar) triangle formed by this and two other points. |
circum3(self, point2, point3, circum=True, eps=8.881784197001252e-16, **wrap_name) Return the radius and center of the smallest circle through or containing this and two other points. |
circum4_(self, *points, **wrap_name) Best-fit a sphere through this and two or more other points. |
compassAngle(self, other, **adjust_wrap) DEPRECATED, use method compassAngleTo. |
compassAngleTo(self, other, **adjust_wrap) Return the angle from North for the direction vector between this and an other point. |
cosineAndoyerLambertTo(self, other, **wrap) Compute the distance between this and an other point using the Andoyer-Lambert correction of the Law of Cosines formula. |
cosineForsytheAndoyerLambertTo(self, other, **wrap) Compute the distance between this and an other point using the Forsythe-Andoyer-Lambert correction of the Law of Cosines formula. |
cosineLawTo(self, other, radius=None, **wrap) Compute the distance between this and an other point using the spherical Law of Cosines formula. |
destinationXyz(self, delta, LatLon=None, **LatLon_kwds) Calculate the destination using a local delta from this point. |
equals(self, other, eps=None) DEPRECATED, use method isequalTo. |
equals3(self, other, eps=None) DEPRECATED, use method isequalTo3. |
equirectangularTo(self, other, **radius_adjust_limit_wrap) Compute the distance between this and an other point using the Equirectangular Approximation / Projection. |
euclideanTo(self, other, **radius_adjust_wrap) Approximate the `Euclidian` distance between this and an other point. |
flatLocalTo(self, other, radius=None, **wrap) Compute the distance between this and an other point using the ellipsoidal Earth to plane projection aka Hubeny formula. |
flatPolarTo(self, other, **radius_wrap) Compute the distance between this and an other point using the polar coordinate flat-Earth formula. |
hartzell(self, los=False, earth=None) Compute the intersection of a Line-Of-Sight from this (geodetic) Point-Of-View (pov) with this point's ellipsoid surface. |
haversineTo(self, other, **radius_wrap) Compute the distance between this and an other point using the Haversine formula. |
height4(self, earth=None, normal=True, LatLon=None, **LatLon_kwds) Compute the projection of this point on and the height above or below this datum's ellipsoid surface. |
heightStr(self, prec=-2, m=`'``m``'`) Return this point's `height` as `str`ing. |
hubenyTo(self, other, radius=None, **wrap) Compute the distance between this and an other point using the ellipsoidal Earth to plane projection aka Hubeny formula. |
intersecant2(self, *args, **kwds) Not implemented, throws a `NotImplementedError` always. |
isantipode(self, other, eps=2.220446049250313e-16) DEPRECATED, use method isantipodeTo. |
isantipodeTo(self, other, eps=2.220446049250313e-16) Check whether this and an other point are antipodal, on diametrically opposite sides of the earth. |
isequalTo(self, other, eps=None) Compare this point with an other point, ignoring height. |
isequalTo3(self, other, eps=None) Compare this point with an other point, including height. |
latlon2(self, ndigits=0) Return this point's lat- and longitude in `degrees`, rounded. |
latlon2round(self, ndigits=0) DEPRECATED, use method latlon2. |
latlon_(self, ndigits=0) DEPRECATED, use method latlon2. |
nearestOn6(self, points, closed=False, height=None, wrap=False) Locate the point on a path or polygon closest to this point. |
nearestTo(self, *args, **kwds) Not implemented, throws a `NotImplementedError` always. |
normal(self) Normalize this point in-place to `abs(lat) <= 90` and `abs(lon) <= 180`. |
philam2(self, ndigits=0) Return this point's lat- and longitude in `radians`, rounded. |
points(self, points, **closed) DEPRECATED, use method points2. |
points2(self, points, closed=True) Check a path or polygon represented by points. |
radii11(self, point2, point3, wrap=False) Return the radii of the `Circum-`, `In-`, Soddy and `Tangent` circles of a (planar) triangle formed by this and two other points. |
rhumbAzimuthTo(self, other, exact=False, radius=None, wrap=False, b360=False) Return the azimuth (bearing) of a rhumb line (loxodrome) between this and an other (ellipsoidal) point. |
rhumbDestination(self, distance, azimuth, radius=None, height=None, exact=False, **name) Return the destination point having travelled the given distance from this point along a rhumb line (loxodrome) of the given azimuth. |
rhumbDistanceTo(self, other, exact=False, radius=None, wrap=False) Return the distance from this to an other point along a rhumb line (loxodrome). |
rhumbIntersecant2(self, circle, point, other, height=None, **exact_radius_wrap_eps_tol) Compute the intersections of a circle and a rhumb line given as two points or as a point and azimuth. |
rhumbLine(self, other, exact=False, radius=None, wrap=False, **name_caps) Get a rhumb line through this point at a given azimuth or through this and an other point. |
rhumbMidpointTo(self, other, exact=False, radius=None, height=None, fraction=0.5, **wrap_name) Return the (loxodromic) midpoint on the rhumb line between this and an other point. |
thomasTo(self, other, **wrap) Compute the distance between this and an other point using Thomas' formula. |
to2ab(self) DEPRECATED, use property philam. |
to3llh(self, height=None) DEPRECATED, use property latlonheight or `latlon.to3Tuple(height)`. |
to3xyz(self) DEPRECATED, use property xyz or method toNvector, toVector, toVector3d or perhaps (geocentric) toEcef. |
toCartesian(self, height=None, Cartesian=None, **Cartesian_kwds) Convert this point to cartesian, geocentric coordinates, also known as Earth-Centered, Earth-Fixed (ECEF). |
toDatum(self, datum2, height=None, **name) Must be overloaded. |
toEcef(self, height=None, M=False) Convert this point to geocentric coordinates, also known as Earth-Centered, Earth-Fixed (ECEF). |
toLocal(self, Xyz=None, ltp=None, **Xyz_kwds) Convert this geodetic point to local `X`, `Y` and `Z`. |
toLtp(self, Ecef=None, **name) Return the local tangent plane (LTP) for this point. |
toNormal(self, deep=False, **name) Get this point normalized to `abs(lat) <= 90` and `abs(lon) <= 180`. |
toNvector(self, h=None, Nvector=None, **name_Nvector_kwds) Convert this point to `n-vector` (normal to the earth's surface) components, including height. |
toStr(self, form=`'``dms``'`, joined=', ', m=`'``m``'`, **prec_sep_s_D_M_S) Convert this point to a "lat, lon[, +/-height]" string, formatted in the given `format`. |
toVector(self, Vector=None, **Vector_kwds) Convert this point to a `Vector` with the geocentric `(x, y, z)` (ECEF) coordinates, ignoring height. |
toVector3d(self, norm=True, **Vector3d_kwds) Convert this point to a Vector3d with the geocentric `(x, y, z)` (ECEF) coordinates, ignoring height. |
toWm(self, **toWm_kwds) Convert this point to a WM coordinate. |
vincentysTo(self, other, **radius_wrap) Compute the distance between this and an other point using Vincenty's spherical formula. |
Inherited from `named._NamedBase`: `__repr__`, `others`, `toRepr` Inherited from `named._Named`: `__imatmul__`, `__matmul__`, `__rmatmul__`, `attrs`, `classof`, `copy`, `dup`, `methodname`, `rename`, `renamed`, `toStr2` Inherited from `object`: `__delattr__`, `__format__`, `__getattribute__`, `__hash__`, `__new__`, `__reduce__`, `__reduce_ex__`, `__setattr__`, `__sizeof__`, `__subclasshook__`

Properties
| Ecef Get the ECEF class (EcefKarney), once.
| clipid Get the (polygonal) clip (`int`).
| datum Must be overloaded.
| ellipsoidalLatLon Get the `LatLon type` iff ellipsoidal, overloaded in LatLonEllipsoidalBase.
| height Get the height (`meter`).
| isEllipsoidal Check whether this point is ellipsoidal (`bool` or `None` if unknown).
| isSpherical Check whether this point is spherical (`bool` or `None` if unknown).
| isnormal Return `True` if this point is normal (`bool`), meaning `abs(lat) <= 90` and `abs(lon) <= 180`.
| lam Get the longitude (`radians`).
| lat Get the latitude (`degrees90`).
| latlon Get the lat- and longitude (LatLon2Tuple`(lat, lon)`).
| latlonheight Get the lat-, longitude and height (LatLon3Tuple`(lat, lon, height)`).
| lon Get the longitude (`degrees180`).
| phi Get the latitude (`radians`).
| philam Get the lat- and longitude (PhiLam2Tuple`(phi, lam)`).
| philamheight Get the lat-, longitude in `radians` and height (PhiLam3Tuple`(phi, lam, height)`).
| sphericalLatLon Get the `LatLon type` iff spherical, overloaded in LatLonSphericalBase.
| xyz Get the geocentric `(x, y, z)` coordinates (Vector3Tuple`(x, y, z)`)
| xyzh Get the geocentric `(x, y, z)` coordinates and height (Vector4Tuple`(x, y, z, h)`)
Inherited from `named._Named`: `classname`, `classnaming`, `iteration`, `name`, `named`, `named2`, `named3`, `named4`, `sizeof` Inherited from `object`: `__class__`

Method Details

### PointsIter (self, points, loop=0, dedup=False, wrap=False) |
Return a `PointsIter` iterator. Arguments: `points` - The path or polygon points (`LatLon`[]) `loop` - Number of loop-back points (non-negative `int`). `dedup` - If `True`, skip duplicate points (`bool`). `wrap` - If `True`, wrap or normalize the enum-/iterated `points` (`bool`). Returns: A new `PointsIter` iterator. Raises: `PointsError` - Insufficient number of `points`.

### __init__ (self, latlonh, lon=None, height=0, datum=None, **wrap_name) (Constructor) |
New `LatLon`. Arguments: `latlonh` - Latitude (`degrees` or DMS `str` with N or S suffix) or a previous `LatLon` instance provided `lon=None`. `lon` - Longitude (`degrees` or DMS `str` with E or W suffix) or C(None), indicating `latlonh` is a `LatLon`. `height` - Optional height above (or below) the earth surface (`meter`, conventionally). `datum` - Optional datum (Datum, Ellipsoid, Ellipsoid2, a_f2Tuple or scalar radius) or `None`. `wrap_name` - Optional `name=NN` (`str`) and optional keyword argument `wrap=False`, if `True`, wrap or normalize `lat` and `lon` (`bool`). Returns: New instance (`LatLon`). Raises: `RangeError` - A `lon` or `lat` value outside the valid range and rangerrors set to `True`. `TypeError` - If `latlonh` is not a `LatLon`. `UnitError` - Invalid `lat`, `lon` or `height`. Overrides: object.__init__

### __str__ (self) (Informal representation operator) |
Default `str(self)`. Overrides: object.__str__ (inherited documentation)

### antipode (self, height=None) |
Return the antipode, the point diametrically opposite to this point. Arguments: `height` - Optional height of the antipode (`meter`), this point's height otherwise. Returns: The antipodal point (`LatLon`).

### bounds (self, wide, tall, radius=6371008.771415) |
DEPRECATED, use method `boundsOf`. Decorators: `@deprecated_method`

### boundsOf (self, wide, tall, radius=6371008.771415, height=None, **name) |
Return the SW and NE lat-/longitude of a great circle bounding box centered at this location. Arguments: `wide` - Longitudinal box width (`meter`, same units as `radius` or `degrees` if `radius` is `None`). `tall` - Latitudinal box size (`meter`, same units as `radius` or `degrees` if `radius` is `None`). `radius` - Mean earth radius (`meter`) or `None` if both `wide` and `tall` are in `degrees`. `height` - Height for `latlonSW` and `latlonNE` (`meter`), overriding the point's height. `name` - Optional `name=NN` (`str`). Returns: A Bounds2Tuple`(latlonSW, latlonNE)`, the lower-left and upper-right corner (`LatLon`). See Also: https://www.Movable-Type.co.UK/scripts/latlong-db.html

### chordTo (self, other, height=None, wrap=False) |
Compute the length of the chord through the earth between this and an other point. Arguments: `other` - The other point (`LatLon`). `height` - Overriding height for both points (`meter`), or if `None`, use each point's height. `wrap` - If `True`, wrap or normalize the `other` point (`bool`). Returns: The chord length (conventionally `meter`). Raises: `TypeError` - The `other` point is not `LatLon`.

### circin6 (self, point2, point3, eps=8.881784197001252e-16, **wrap_name) |
Return the radius and center of the inscribed aka In-circle of the (planar) triangle formed by this and two other points. Arguments: `point2` - Second point (`LatLon`). `point3` - Third point (`LatLon`). `eps` - Tolerance for function pygeodesy.trilaterate3d2. `wrap_name` - Optional `name=NN` (`str`) and optional keyword argument `wrap=False`, if `True`, wrap or normalize the `points` (`bool`). Returns: Circin6Tuple`(radius, center, deltas, cA, cB, cC)`. The `center` and contact points `cA`, `cB` and `cC`, each an instance of this (sub-)class, are co-planar with this and the two given points, see the Note below. Raises: `ImportError` - Package `numpy` not found, not installed or older than version 1.10. `IntersectionError` - Near-coincident or -colinear points or a trilateration or `numpy` issue. `TypeError` - Invalid `point2` or `point3`. Note: The `center` is trilaterated in cartesian (ECEF) space and converted back to geodetic lat-, longitude and height. The latter, conventionally in `meter` indicates whether the `center` is above, below or on the surface of the earth model. If `deltas` is `None`, the `center` is unambigous. Otherwise `deltas` is a LatLon3Tuple`(lat, lon, height)` representing the differences between both results from pygeodesy.trilaterate3d2 and `center` is the mean thereof. See Also: Function pygeodesy.circin6, method circum3, Incircle and Contact Triangle.

### circum3 (self, point2, point3, circum=True, eps=8.881784197001252e-16, **wrap_name) |
Return the radius and center of the smallest circle through or containing this and two other points. Arguments: `point2` - Second point (`LatLon`). `point3` - Third point (`LatLon`). `circum` - If `True` return the `circumradius` and `circumcenter`, always, ignoring the Meeus' Type I case (`bool`). `eps` - Tolerance for function pygeodesy.trilaterate3d2. `wrap_name` - Optional `name=NN` (`str`) and optional keyword argument `wrap=False`, if `True`, wrap or normalize the `points` (`bool`). Returns: A Circum3Tuple`(radius, center, deltas)`. The `center`, an instance of this (sub-)class, is co-planar with this and the two given points. If `deltas` is `None`, the `center` is unambigous. Otherwise `deltas` is a LatLon3Tuple`(lat, lon, height)` representing the difference between both results from pygeodesy.trilaterate3d2 and `center` is the mean thereof. Raises: `ImportError` - Package `numpy` not found, not installed or older than version 1.10. `IntersectionError` - Near-concentric, -coincident or -colinear points, incompatible `Ecef` classes or a trilateration or `numpy` issue. `TypeError` - Invalid `point2` or `point3`. Note: The `center` is trilaterated in cartesian (ECEF) space and converted back to geodetic lat-, longitude and height. The latter, conventionally in `meter` indicates whether the `center` is above, below or on the surface of the earth model. If `deltas` is `None`, the `center` is unambigous. Otherwise `deltas` is a LatLon3Tuple`(lat, lon, height)` representing the difference between both results from pygeodesy.trilaterate3d2 and `center` is the mean thereof. See Also: Function pygeodesy.circum3 and methods circin6 and circum4_.

### circum4_ (self, *points, **wrap_name) |
Best-fit a sphere through this and two or more other points. Arguments: `points` - The other points (each a `LatLon`). `wrap_name` - Optional `name=NN` (`str`) and optional keyword argument `wrap=False`, if `True`, wrap or normalize the `points` (`bool`). Returns: Circum4Tuple`(radius, center, rank, residuals)` with `center` an instance of this (sub-)class. Raises: `ImportError` - Package `numpy` not found, not installed or older than version 1.10. `NumPyError` - Some `numpy` issue. `TypeError` - One of the `points` invalid. `ValueError` - Too few `points`. See Also: Function pygeodesy.circum4_ and circum3.

### compassAngle (self, other, **adjust_wrap) |
DEPRECATED, use method compassAngleTo. Decorators: `@deprecated_method`

### compassAngleTo (self, other, **adjust_wrap) |
Return the angle from North for the direction vector between this and an other point. Suitable only for short, non-near-polar vectors up to a few hundred Km or Miles. Use method `initialBearingTo` for larger distances. Arguments: `other` - The other point (`LatLon`). `adjust_wrap` - Optional keyword arguments for function pygeodesy.compassAngle. Returns: Compass angle from North (`degrees360`). Raises: `TypeError` - The `other` point is not `LatLon`. Note: Courtesy of Martin Schultz. See Also: Local, flat earth approximation.

### cosineAndoyerLambertTo (self, other, **wrap) |
Compute the distance between this and an other point using the Andoyer-Lambert correction of the Law of Cosines formula. Arguments: `other` - The other point (`LatLon`). `wrap` - Optional keyword argument `wrap=False`, if `True`, wrap or normalize and unroll the `other` point (`bool`). Returns: Distance (`meter`, same units as the axes of this point's datum ellipsoid). Raises: `TypeError` - The `other` point is not `LatLon`. See Also: Function pygeodesy.cosineAndoyerLambert and methods cosineForsytheAndoyerLambertTo, cosineLawTo, `distanceTo*`, equirectangularTo, euclideanTo, flatLocalTo/hubenyTo, flatPolarTo, haversineTo, thomasTo and vincentysTo.

### cosineForsytheAndoyerLambertTo (self, other, **wrap) |
Compute the distance between this and an other point using the Forsythe-Andoyer-Lambert correction of the Law of Cosines formula. Arguments: `other` - The other point (`LatLon`). `wrap` - Optional keyword argument `wrap=False`, if `True`, wrap or normalize and unroll the `other` point (`bool`). Returns: Distance (`meter`, same units as the axes of this point's datum ellipsoid). Raises: `TypeError` - The `other` point is not `LatLon`. See Also: Function pygeodesy.cosineForsytheAndoyerLambert and methods cosineAndoyerLambertTo, cosineLawTo, `distanceTo*`, equirectangularTo, euclideanTo, flatLocalTo/hubenyTo, flatPolarTo, haversineTo, thomasTo and vincentysTo.

### cosineLawTo (self, other, radius=None, **wrap) |
Compute the distance between this and an other point using the spherical Law of Cosines formula. Arguments: `other` - The other point (`LatLon`). `radius` - Mean earth radius (`meter`) or `None` for the mean radius of this point's datum ellipsoid. `wrap` - Optional keyword argument `wrap=False`, if `True`, wrap or normalize and unroll the `other` point (`bool`). Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - The `other` point is not `LatLon`. See Also: Function pygeodesy.cosineLaw and methods cosineAndoyerLambertTo, cosineForsytheAndoyerLambertTo, `distanceTo*`, equirectangularTo, euclideanTo, flatLocalTo/hubenyTo, flatPolarTo, haversineTo, thomasTo and vincentysTo.

### destinationXyz (self, delta, LatLon=None, **LatLon_kwds) |
Calculate the destination using a local delta from this point. Arguments: `delta` - Local delta to the destination (XyzLocal, Enu, Ned or Local9Tuple). `LatLon` - Optional (geodetic) class to return the destination or `None`. `LatLon_kwds` - Optional, additional `LatLon` keyword arguments, ignored if `LatLon is None`. Returns: Destination as a `LatLon(lat, lon, **LatLon_kwds)` instance or if `LatLon is None`, a LatLon3Tuple`(lat, lon, height)` respectively LatLon4Tuple`(lat, lon, height, datum)` depending on whether a `datum` keyword is un-/specified. Raises: `TypeError` - Invalid `delta`, `LatLon` or `LatLon_kwds`.

### equals (self, other, eps=None) |
DEPRECATED, use method isequalTo. Decorators: `@deprecated_method`

### equals3 (self, other, eps=None) |
DEPRECATED, use method isequalTo3. Decorators: `@deprecated_method`

### equirectangularTo (self, other, **radius_adjust_limit_wrap) |
Compute the distance between this and an other point using the Equirectangular Approximation / Projection. Suitable only for short, non-near-polar distances up to a few hundred Km or Miles. Use method haversineTo or `distanceTo*` for more accurate and/or larger distances. Arguments: `other` - The other point (`LatLon`). `radius_adjust_limit_wrap` - Optional keyword arguments for function pygeodesy.equirectangular, overriding the default mean `radius` of this point's datum ellipsoid. Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - The `other` point is not `LatLon`. See Also: Function pygeodesy.equirectangular and methods cosineAndoyerLambertTo, cosineForsytheAndoyerLambertTo, cosineLawTo, `distanceTo*`, `euclideanTo`, flatLocalTo/hubenyTo, flatPolarTo, haversineTo, thomasTo and vincentysTo.

### euclideanTo (self, other, **radius_adjust_wrap) |
Approximate the `Euclidian` distance between this and an other point. See function pygeodesy.euclidean for the available `options`. Arguments: `other` - The other point (`LatLon`). `radius_adjust_wrap` - Optional keyword arguments for function pygeodesy.euclidean, overriding the default mean `radius` of this point's datum ellipsoid. Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - The `other` point is not `LatLon`. See Also: Function pygeodesy.euclidean and methods cosineAndoyerLambertTo, cosineForsytheAndoyerLambertTo, cosineLawTo, `distanceTo*`, equirectangularTo, flatLocalTo/hubenyTo, flatPolarTo, haversineTo, thomasTo and vincentysTo.

### flatLocalTo (self, other, radius=None, **wrap) |
Compute the distance between this and an other point using the ellipsoidal Earth to plane projection aka Hubeny formula. Arguments: `other` - The other point (`LatLon`). `radius` - Mean earth radius (`meter`) or `None` for the equatorial radius of this point's datum ellipsoid. `wrap` - Optional keyword argument `wrap=False`, if `True`, wrap or normalize and unroll the `other` point (`bool`). Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - The `other` point is not `LatLon`. `ValueError` - Invalid `radius`. See Also: Function pygeodesy.flatLocal/pygeodesy.hubeny, methods cosineAndoyerLambertTo, cosineForsytheAndoyerLambertTo, cosineLawTo, `distanceTo*`, equirectangularTo, euclideanTo, flatPolarTo, haversineTo, thomasTo and vincentysTo and local, flat Earth approximation.

### flatPolarTo (self, other, **radius_wrap) |
Compute the distance between this and an other point using the polar coordinate flat-Earth formula. Arguments: `other` - The other point (`LatLon`). `radius_wrap` - Optional keyword arguments for function pygeodesy.flatPolar, overriding the default mean `radius` of this point's datum ellipsoid. Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - The `other` point is not `LatLon`. See Also: Function pygeodesy.flatPolar and methods cosineAndoyerLambertTo, cosineForsytheAndoyerLambertTo, cosineLawTo, `distanceTo*`, equirectangularTo, euclideanTo, flatLocalTo/hubenyTo, haversineTo, thomasTo and vincentysTo.

### hartzell (self, los=False, earth=None) |
Compute the intersection of a Line-Of-Sight from this (geodetic) Point-Of-View (pov) with this point's ellipsoid surface. Arguments: `los` - Line-Of-Sight, direction to the ellipsoid (Los, Vector3d), `True` for the normal, plumb onto the surface or False or `None` to point to the center of the ellipsoid. `earth` - The earth model (Datum, Ellipsoid, Ellipsoid2, a_f2Tuple or `scalar` radius in `meter`), overriding this point's `datum` ellipsoid. Returns: The intersection (`LatLon`) with `.height` set to the distance to this `pov`. Raises: `IntersectionError` - Null or bad `pov` or `los`, this `pov` is inside the ellipsoid or `los` points outside or away from the ellipsoid. `TypeError` - Invalid `los` or invalid or undefined `earth` or `datum`. See Also: Function hartzell for further details.

### haversineTo (self, other, **radius_wrap) |
Compute the distance between this and an other point using the Haversine formula. Arguments: `other` - The other point (`LatLon`). `radius_wrap` - Optional keyword arguments for function pygeodesy.haversine, overriding the default mean `radius` of this point's datum ellipsoid. Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - The `other` point is not `LatLon`. See Also: Function pygeodesy.haversine and methods cosineAndoyerLambertTo, cosineForsytheAndoyerLambertTo, cosineLawTo, `distanceTo*`, equirectangularTo, euclideanTo, flatLocalTo/hubenyTo, flatPolarTo, thomasTo and vincentysTo.

### height4 (self, earth=None, normal=True, LatLon=None, **LatLon_kwds) |
Compute the projection of this point on and the height above or below this datum's ellipsoid surface. Arguments: `earth` - A datum, ellipsoid, triaxial ellipsoid or earth radius, overriding this datum (Datum, Ellipsoid, Ellipsoid2, a_f2Tuple, Triaxial, Triaxial_, JacobiConformal or `meter`, conventionally). `normal` - If `True` the projection is the normal to this ellipsoid's surface, otherwise the intersection of the radial line to this ellipsoid's center (`bool`). `LatLon` - Optional class to return the projection, height and datum (`LatLon`) or `None`. `LatLon_kwds` - Optional, additional `LatLon` keyword arguments, ignored if `LatLon is None`. Returns: An instance of class `LatLon` or if `LatLon is None`, a Vector4Tuple`(x, y, z, h)` with the projection `x`, `y` and `z` coordinates and height `h` in `meter`, conventionally. Raises: `TriaxialError` - No convergence in triaxial root finding. `TypeError` - Invalid `earth` or triaxial `earth` couldn't be converted to biaxial `LatLon` datum. Note: Use keyword argument `height=0` to override `LatLon.height` to {0} or any other `scalar`, conventionally in `meter`. See Also: Methods Ellipsoid.height4 and Triaxial_.height4 for more information.

### heightStr (self, prec=-2, m=`'``m``'`) |
Return this point's `height` as `str`ing. Arguments: `prec` - Number of (decimal) digits, unstripped (`int`). `m` - Optional unit of the height (`str`). See Also: Function pygeodesy.hstr.

### hubenyTo (self, other, radius=None, **wrap) |
Compute the distance between this and an other point using the ellipsoidal Earth to plane projection aka Hubeny formula. Arguments: `other` - The other point (`LatLon`). `radius` - Mean earth radius (`meter`) or `None` for the equatorial radius of this point's datum ellipsoid. `wrap` - Optional keyword argument `wrap=False`, if `True`, wrap or normalize and unroll the `other` point (`bool`). Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - The `other` point is not `LatLon`. `ValueError` - Invalid `radius`. See Also: Function pygeodesy.flatLocal/pygeodesy.hubeny, methods cosineAndoyerLambertTo, cosineForsytheAndoyerLambertTo, cosineLawTo, `distanceTo*`, equirectangularTo, euclideanTo, flatPolarTo, haversineTo, thomasTo and vincentysTo and local, flat Earth approximation.

### isantipode (self, other, eps=2.220446049250313e-16) |
DEPRECATED, use method isantipodeTo. Decorators: `@deprecated_method`

### isantipodeTo (self, other, eps=2.220446049250313e-16) |
Check whether this and an other point are antipodal, on diametrically opposite sides of the earth. Arguments: `other` - The other point (`LatLon`). `eps` - Tolerance for near-equality (`degrees`). Returns: `True` if points are antipodal within the given tolerance, `False` otherwise.

### isequalTo (self, other, eps=None) |
Compare this point with an other point, ignoring height. Arguments: `other` - The other point (`LatLon`). `eps` - Tolerance for equality (`degrees`). Returns: `True` if both points are identical, ignoring height, `False` otherwise. Raises: `TypeError` - The `other` point is not `LatLon` or mismatch of the `other` and this `class` or `type`. `UnitError` - Invalid `eps`. See Also: Method isequalTo3.

### isequalTo3 (self, other, eps=None) |
Compare this point with an other point, including height. Arguments: `other` - The other point (`LatLon`). `eps` - Tolerance for equality (`degrees`). Returns: `True` if both points are identical including height, `False` otherwise. Raises: `TypeError` - The `other` point is not `LatLon` or mismatch of the `other` and this `class` or `type`. See Also: Method isequalTo.

### latlon2 (self, ndigits=0) |
Return this point's lat- and longitude in `degrees`, rounded. Arguments: `ndigits` - Number of (decimal) digits (`int`). Returns: A LatLon2Tuple`(lat, lon)`, both `float` and rounded away from zero. Note: The `round`ed values are always `float`, also if `ndigits` is omitted.

### latlon2round (self, ndigits=0) |
DEPRECATED, use method latlon2. Decorators: `@deprecated_method`

### latlon_ (self, ndigits=0) |
DEPRECATED, use method latlon2. Decorators: `@deprecated_method`

### nearestOn6 (self, points, closed=False, height=None, wrap=False) |
Locate the point on a path or polygon closest to this point. Points are converted to and distances are computed in geocentric, cartesian space. Arguments: `points` - The path or polygon points (`LatLon`[]). `closed` - Optionally, close the polygon (`bool`). `height` - Optional height, overriding the height of this and all other points (`meter`). If `None`, take the height of points into account for distances. `wrap` - If `True`, wrap or normalize and unroll the `points` (`bool`). Returns: A NearestOn6Tuple`(closest, distance, fi, j, start, end)` with the `closest`, the `start` and the `end` point each an instance of this `LatLon` and `distance` in `meter`, same units as the cartesian axes. Raises: `PointsError` - Insufficient number of `points`. `TypeError` - Some `points` or some `points`' `Ecef` invalid. `ValueError` - Some `points`' `Ecef` is incompatible. See Also: Function nearestOn6.

### normal (self) |
Normalize this point in-place to `abs(lat) <= 90` and `abs(lon) <= 180`. Returns: `True` if this point was normal, `False` if it wasn't (but is now). See Also: Property isnormal and method toNormal.

### philam2 (self, ndigits=0) |
Return this point's lat- and longitude in `radians`, rounded. Arguments: `ndigits` - Number of (decimal) digits (`int`). Returns: A PhiLam2Tuple`(phi, lam)`, both `float` and rounded away from zero. Note: The `round`ed values are always `float`, also if `ndigits` is omitted.

### points (self, points, **closed) |
DEPRECATED, use method points2. Decorators: `@deprecated_method`

### points2 (self, points, closed=True) |
Check a path or polygon represented by points. Arguments: `points` - The path or polygon points (`LatLon`[]) `closed` - Optionally, consider the polygon closed, ignoring any duplicate or closing final `points` (`bool`). Returns: A Points2Tuple`(number, points)`, an `int` and `list` or `tuple`. Raises: `PointsError` - Insufficient number of `points`. `TypeError` - Some `points` are not `LatLon`.

### radii11 (self, point2, point3, wrap=False) |
Return the radii of the `Circum-`, `In-`, Soddy and `Tangent` circles of a (planar) triangle formed by this and two other points. Arguments: `point2` - Second point (`LatLon`). `point3` - Third point (`LatLon`). `wrap` - If `True`, wrap or normalize `point2` and `point3` (`bool`). Returns: Radii11Tuple`(rA, rB, rC, cR, rIn, riS, roS, a, b, c, s)`. Raises: `IntersectionError` - Near-coincident or -colinear points. `TypeError` - Invalid `point2` or `point3`. See Also: Function pygeodesy.radii11, Incircle, Soddy Circles and Tangent Circles.

### rhumbAzimuthTo (self, other, exact=False, radius=None, wrap=False, b360=False) |
Return the azimuth (bearing) of a rhumb line (loxodrome) between this and an other (ellipsoidal) point. Arguments: `other` - The other point (`LatLon`). `exact` - Exact `Rhumb...` to use (`bool` or `Rhumb...`), see method Ellipsoid.rhumb_. `radius` - Optional earth radius (`meter`) or earth model (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple), overriding this point's datum. `wrap` - If `True`, wrap or normalize and unroll the `other` point (`bool`). `b360` - If `True`, return the azimuth as bearing in compass degrees (`bool`). Returns: Rhumb azimuth (`degrees180` or compass `degrees360`). Raises: `TypeError` - The `other` point is incompatible or `radius` is invalid.

### rhumbDestination (self, distance, azimuth, radius=None, height=None, exact=False, **name) |
Return the destination point having travelled the given distance from this point along a rhumb line (loxodrome) of the given azimuth. Arguments: `distance` - Distance travelled (`meter`, same units as this point's datum (ellipsoid) axes or `radius`, may be negative. `azimuth` - Azimuth (bearing) of the rhumb line (compass `degrees`). `radius` - Optional earth radius (`meter`) or earth model (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple), overriding this point's datum. `height` - Optional height, overriding the default height (`meter`). `exact` - Exact `Rhumb...` to use (`bool` or `Rhumb...`), see method Ellipsoid.rhumb_. `name` - Optional `name=NN` (`str`). Returns: The destination point (ellipsoidal `LatLon`). Raises: `TypeError` - Invalid `radius`. `ValueError` - Invalid `distance`, `azimuth`, `radius` or `height`.

### rhumbDistanceTo (self, other, exact=False, radius=None, wrap=False) |
Return the distance from this to an other point along a rhumb line (loxodrome). Arguments: `other` - The other point (`LatLon`). `exact` - Exact `Rhumb...` to use (`bool` or `Rhumb...`), see method Ellipsoid.rhumb_. `radius` - Optional earth radius (`meter`) or earth model (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple), overriding this point's datum. `wrap` - If `True`, wrap or normalize and unroll the `other` point (`bool`). Returns: Distance (`meter`, the same units as this point's datum (ellipsoid) axes or `radius`. Raises: `TypeError` - The `other` point is incompatible or `radius` is invalid. `ValueError` - Invalid `radius`.

### rhumbIntersecant2 (self, circle, point, other, height=None, **exact_radius_wrap_eps_tol) |
Compute the intersections of a circle and a rhumb line given as two points or as a point and azimuth. Arguments: `circle` - Radius of the circle centered at this location (`meter`), or a point on the circle (this `LatLon`). `point` - The start point of the rhumb line (this `LatLon`). `other` - An other point on (this `LatLon`) or the azimuth of (compass `degrees`) the rhumb line. `height` - Optional height for the intersection points (`meter`, conventionally) or `None` for interpolated heights. `exact_radius_wrap_eps_tol` - Optional keyword arguments, see methods rhumbLine and RhumbLineAux.Intersecant2 or RhumbLine.Intersecant2. Returns: 2-Tuple of the intersection points (representing a chord), each an instance of this class. Both points are the same instance if the rhumb line is tangent to the circle. Raises: `IntersectionError` - The circle and rhumb line do not intersect. `TypeError` - If `point` is not this `LatLon` or `circle` or `other` invalid. `ValueError` - Invalid `circle`, `other`, `height` or `exact_radius_wrap`. See Also: Methods RhumbLineAux.Intersecant2 and RhumbLine.Intersecant2.

### rhumbLine (self, other, exact=False, radius=None, wrap=False, **name_caps) |
Get a rhumb line through this point at a given azimuth or through this and an other point. Arguments: `other` - The azimuth of (compass `degrees`) or an other point on (this `LatLon`) the rhumb line. `exact` - Exact `Rhumb...` to use (`bool` or `Rhumb...`), see method Ellipsoid.rhumb_. `radius` - Optional earth radius (`meter`) or earth model (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple), overriding this point's datum. `wrap` - If `True`, wrap or normalize and unroll the `other` point (`bool`). `name_caps` - Optional `name=str` and `caps`, see RhumbLine or RhumbLineAux `caps`. Returns: A `RhumbLine` instance. Raises: `TypeError` - Invalid `radius` or `other` not `scalar` nor this `LatLon`. See Also: Modules rhumb.aux_ and rhumb.ekx.

### rhumbMidpointTo (self, other, exact=False, radius=None, height=None, fraction=0.5, **wrap_name) |
Return the (loxodromic) midpoint on the rhumb line between this and an other point. Arguments: `other` - The other point (this `LatLon`). `exact` - Exact `Rhumb...` to use (`bool` or `Rhumb...`), see method Ellipsoid.rhumb_. `radius` - Optional earth radius (`meter`) or earth model (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple), overriding this point's datum. `height` - Optional height, overriding the mean height (`meter`). `fraction` - Midpoint location from this point (`scalar`), 0 for this, 1 for the `other`, 0.5 for halfway between this and the `other` point, may be negative or greater than 1. `wrap_name` - Optional `name=NN` (`str`) and optional keyword argument `wrap=False`, if `True`, wrap or normalize and unroll the `other` point (`bool`). Returns: The midpoint at the given `fraction` along the rhumb line (this `LatLon`). Raises: `TypeError` - The `other` point is incompatible or `radius` is invalid. `ValueError` - Invalid `height` or `fraction`.

### thomasTo (self, other, **wrap) |
Compute the distance between this and an other point using Thomas' formula. Arguments: `other` - The other point (`LatLon`). `wrap` - Optional keyword argument `wrap=False`, if `True`, wrap or normalize and unroll the `other` point (`bool`). Returns: Distance (`meter`, same units as the axes of this point's datum ellipsoid). Raises: `TypeError` - The `other` point is not `LatLon`. See Also: Function pygeodesy.thomas and methods cosineAndoyerLambertTo, cosineForsytheAndoyerLambertTo, cosineLawTo, `distanceTo*`, equirectangularTo, euclideanTo, flatLocalTo/hubenyTo, flatPolarTo, haversineTo and vincentysTo.

### to2ab (self) |
DEPRECATED, use property philam. Decorators: `@deprecated_method`

### to3llh (self, height=None) |
DEPRECATED, use property latlonheight or `latlon.to3Tuple(height)`. Decorators: `@deprecated_method`

### to3xyz (self) |
DEPRECATED, use property xyz or method toNvector, toVector, toVector3d or perhaps (geocentric) toEcef. Decorators: `@deprecated_method`

### toCartesian (self, height=None, Cartesian=None, **Cartesian_kwds) |
Convert this point to cartesian, geocentric coordinates, also known as Earth-Centered, Earth-Fixed (ECEF). Arguments: `height` - Optional height, overriding this point's height (`meter`, conventionally). `Cartesian` - Optional class to return the geocentric coordinates (`Cartesian`) or `None`. `Cartesian_kwds` - Optional, additional `Cartesian` keyword arguments, ignored if `Cartesian is None`. Returns: A `Cartesian` or if `Cartesian` is `None`, an Ecef9Tuple`(x, y, z, lat, lon, height, C, M, datum)` with `C=0` and `M` if available. Raises: `TypeError` - Invalid `Cartesian` or `Cartesian_kwds`. See Also: Methods `toNvector`, `toVector` and `toVector3d`.

### toEcef (self, height=None, M=False) |
Convert this point to geocentric coordinates, also known as Earth-Centered, Earth-Fixed (ECEF). Arguments: `height` - Optional height, overriding this point's height (`meter`, conventionally). `M` - Optionally, include the rotation EcefMatrix (`bool`). Returns: An Ecef9Tuple`(x, y, z, lat, lon, height, C, M, datum)` with `C=0` and `M` if available. Raises: `EcefError` - A `.datum` or an ECEF issue.

### toLocal (self, Xyz=None, ltp=None, **Xyz_kwds) |
Convert this geodetic point to local `X`, `Y` and `Z`. Arguments: `Xyz` - Optional class to return `X`, `Y` and `Z` (XyzLocal, Enu, Ned) or `None`. `ltp` - The local tangent plane (LTP) to use, overriding this point's LTP (Ltp). `Xyz_kwds` - Optional, additional `Xyz` keyword arguments, ignored if `Xyz is None`. Returns: An `Xyz` instance or a Local9Tuple`(x, y, z, lat, lon, height, ltp, ecef, M)` if `Xyz is None` (with `M=None`). Raises: `TypeError` - Invalid `ltp`.

### toLtp (self, Ecef=None, **name) |
Return the local tangent plane (LTP) for this point. Arguments: `Ecef` - Optional ECEF class (EcefKarney, ... EcefYou), overriding this point's `Ecef`. `name` - Optional `name=NN` (`str`).

### toNormal (self, deep=False, **name) |
Get this point normalized to `abs(lat) <= 90` and `abs(lon) <= 180`. Arguments: `deep` - If `True` make a deep, otherwise a shallow copy (`bool`). `name` - Optional `name=NN` (`str`). Returns: A copy of this point, normalized (`LatLon`), optionally renamed. See Also: Property isnormal, method normal and function pygeodesy.normal.

### toNvector (self, h=None, Nvector=None, **name_Nvector_kwds) |
Convert this point to `n-vector` (normal to the earth's surface) components, including height. Arguments: `h` - Optional height, overriding this point's height (`meter`). `Nvector` - Optional class to return the `n-vector` components (`Nvector`) or `None`. `name_Nvector_kwds` - Optional `name=NN` (`str`) and optional, additional `Nvector` keyword arguments, ignored if `Nvector is None`. Returns: An `Nvector` or a Vector4Tuple`(x, y, z, h)` if `Nvector` is `None`. Raises: `TypeError` - Invalid `h`, `Nvector` or `name_Nvector_kwds` item. See Also: Methods `toCartesian`, `toVector` and `toVector3d`.

### toStr (self, form=`'``dms``'`, joined=', ', m=`'``m``'`, **prec_sep_s_D_M_S) |
Convert this point to a "lat, lon[, +/-height]" string, formatted in the given `format`. Arguments: `form` - The lat-/longitude `format` to use (`str`), see functions pygeodesy.latDMS or pygeodesy.lonDMS. `joined` - Separator to join the lat-, longitude and heigth strings (`str` or `None` or `NN` for non-joined). `m` - Optional unit of the height (`str`), use `None` to exclude height from the returned string. `prec_sep_s_D_M_S` - Optional `precision`, `separator`, `s_D`, `s_M`, `s_S` and `s_DMS` keyword arguments, see function pygeodesy.latDMS or pygeodesy.lonDMS. Returns: This point in the specified `format`, etc. (`str` or a 2- or 3-tuple `(lat_str, lon_str[, height_str])` if `joined=NN` or `joined=None`). Overrides: named._Named.toStr See Also: Function pygeodesy.latDMS or pygeodesy.lonDMS for more details about keyword arguments `format`, `precision`, `separator`, `s_D`, `s_M`, `s_S` and `s_DMS`.

### toVector (self, Vector=None, **Vector_kwds) |
Convert this point to a `Vector` with the geocentric `(x, y, z)` (ECEF) coordinates, ignoring height. Arguments: `Vector` - Optional class to return the geocentric components (Vector3d) or `None`. `Vector_kwds` - Optional, additional `Vector` keyword arguments, ignored if `Vector is None`. Returns: A named `Vector` or if `Vector` is `None` a named Vector3Tuple`(x, y, z)`. Raises: `TypeError` - Invalid `Vector` or `Vector_kwds` item. See Also: Methods `toCartesian`, `toNvector` and `toVector3d`.

### toVector3d (self, norm=True, **Vector3d_kwds) |
Convert this point to a Vector3d with the geocentric `(x, y, z)` (ECEF) coordinates, ignoring height. Arguments: `norm` - If `False`, don't normalize the coordinates (`bool`). `Vector3d_kwds` - Optional Vector3d keyword arguments. Returns: Named, unit vector or vector (Vector3d). Raises: `TypeError` - Invalid `Vector3d_kwds` item. See Also: Methods `toCartesian`, `toNvector` and `toVector`.

### toWm (self, **toWm_kwds) |
Convert this point to a WM coordinate. Arguments: `toWm_kwds` - Optional pygeodesy.toWm keyword arguments. Returns: The WM coordinate (Wm). See Also: Function pygeodesy.toWm.

### vincentysTo (self, other, **radius_wrap) |
Compute the distance between this and an other point using Vincenty's spherical formula. Arguments: `other` - The other point (`LatLon`). `radius_wrap` - Optional keyword arguments for function pygeodesy.vincentys, overriding the default mean `radius` of this point's datum ellipsoid. Returns: Distance (`meter`, same units as `radius`). Raises: `TypeError` - The `other` point is not `LatLon`. See Also: Function pygeodesy.vincentys and methods cosineAndoyerLambertTo, cosineForsytheAndoyerLambertTo, cosineLawTo, `distanceTo*`, equirectangularTo, euclideanTo, flatLocalTo/hubenyTo, flatPolarTo, haversineTo and thomasTo.

Property Details

### Ecef Get the ECEF class (EcefKarney), once. Get method: Ecef(self) - Get the ECEF class (EcefKarney), once. Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### clipid Get the (polygonal) clip (`int`). Get method: clipid(self) - Get the (polygonal) clip (`int`). Set method: clipid(self, clipid) - Get the (polygonal) clip (`int`).

### datum Must be overloaded. Get method: datum(self) - Must be overloaded. Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### ellipsoidalLatLon Get the `LatLon type` iff ellipsoidal, overloaded in LatLonEllipsoidalBase. Get method: ellipsoidalLatLon(self) - Get the `LatLon type` iff ellipsoidal, overloaded in LatLonEllipsoidalBase. Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### height Get the height (`meter`). Get method: height(self) - Get the height (`meter`). Set method: height(self, height) - Set the height (`meter`). Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### isEllipsoidal Check whether this point is ellipsoidal (`bool` or `None` if unknown). Get method: isEllipsoidal(self) - Check whether this point is ellipsoidal (`bool` or `None` if unknown). Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### isSpherical Check whether this point is spherical (`bool` or `None` if unknown). Get method: isSpherical(self) - Check whether this point is spherical (`bool` or `None` if unknown). Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### isnormal Return `True` if this point is normal (`bool`), meaning `abs(lat) <= 90` and `abs(lon) <= 180`. Get method: isnormal(self) - Return `True` if this point is normal (`bool`), meaning `abs(lat) <= 90` and `abs(lon) <= 180`. Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value. See Also: Methods normal, toNormal and functions isnormal and normal.

### lam Get the longitude (`radians`). Get method: lam(self) - Get the longitude (`radians`). Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### lat Get the latitude (`degrees90`). Get method: lat(self) - Get the latitude (`degrees90`). Set method: lat(self, lat) - Set the latitude (`str[N|S]` or `degrees`). Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### latlon Get the lat- and longitude (LatLon2Tuple`(lat, lon)`). Get method: latlon(self) - Get the lat- and longitude (LatLon2Tuple`(lat, lon)`). Set method: latlon(self, latlonh) - Set the lat- and longitude and optionally the height (2- or 3-tuple or comma- or space-separated `str` of `degrees90`, `degrees180` and `meter`). Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### latlonheight Get the lat-, longitude and height (LatLon3Tuple`(lat, lon, height)`). Get method: latlonheight(self) - Get the lat-, longitude and height (LatLon3Tuple`(lat, lon, height)`). Set method: latlonheight(self, latlonh) - Set the lat- and longitude and optionally the height (2- or 3-tuple or comma- or space-separated `str` of `degrees90`, `degrees180` and `meter`). Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### lon Get the longitude (`degrees180`). Get method: lon(self) - Get the longitude (`degrees180`). Set method: lon(self, lon) - Set the longitude (`str[E|W]` or `degrees`). Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### phi Get the latitude (`radians`). Get method: phi(self) - Get the latitude (`radians`). Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### philam Get the lat- and longitude (PhiLam2Tuple`(phi, lam)`). Get method: philam(self) - Get the lat- and longitude (PhiLam2Tuple`(phi, lam)`). Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### philamheight Get the lat-, longitude in `radians` and height (PhiLam3Tuple`(phi, lam, height)`). Get method: philamheight(self) - Get the lat-, longitude in `radians` and height (PhiLam3Tuple`(phi, lam, height)`). Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### sphericalLatLon Get the `LatLon type` iff spherical, overloaded in LatLonSphericalBase. Get method: sphericalLatLon(self) - Get the `LatLon type` iff spherical, overloaded in LatLonSphericalBase. Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### xyz Get the geocentric `(x, y, z)` coordinates (Vector3Tuple`(x, y, z)`) Get method: xyz(self) - Get the geocentric `(x, y, z)` coordinates (Vector3Tuple`(x, y, z)`) Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### xyzh Get the geocentric `(x, y, z)` coordinates and height (Vector4Tuple`(x, y, z, h)`) Get method: xyzh(self) - Get the geocentric `(x, y, z)` coordinates and height (Vector4Tuple`(x, y, z, h)`) Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.