Package pygeodesy :: Module ellipsoidalBase :: Class LatLonEllipsoidalBase |
[frames] | no frames]

# Class LatLonEllipsoidalBase

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

Known Subclasses:
  - ellipsoidalBaseDI.LatLonEllipsoidalBaseDI
  - , ellipsoidalNvector.LatLon

(INTERNAL) Base class for ellipsoidal `LatLon`s.

Instance Methods
__init__(self, latlonh, lon=None, height=0, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran`...`, reframe=None, epoch=None, wrap=False, **name) Create an ellipsoidal `LatLon` point from the given lat-, longitude and height on the given datum, reference frame and epoch. |
antipode(self, height=None) Return the antipode, the point diametrically opposite to this point. |
convertDatum(self, datum2) DEPRECATED, use method toDatum. |
convertRefFrame(self, reframe2) DEPRECATED, use method toRefFrame. |
distanceTo2(self, other, wrap=False) Approximate the distance and (initial) bearing between this and an other (ellipsoidal) point based on the radii of curvature. |
elevation2(self, adjust=True, datum=None, timeout=2) Return elevation of this point for its or the given datum, ellipsoid or sphere. |
ellipsoid(self, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran`...`) Return the ellipsoid of this point's datum or the given datum. |
ellipsoids(self, other) Check the type and ellipsoid of this and an other point's datum. |
geoidHeight2(self, adjust=False, datum=None, timeout=2) Return geoid height of this point for its or the given datum, ellipsoid or sphere. |
intermediateTo(self, other, fraction, height=None, wrap=False) Must be overloaded. |
intersection3(self, end1, other, end2, height=None, wrap=False, equidistant=None, tol=0.001) Iteratively compute the intersection point of two lines, each defined by two points or a start point and bearing from North. |
intersections2(self, radius1, other, radius2, height=None, wrap=False, equidistant=None, tol=0.001) Iteratively compute the intersection points of two circles, each defined by a center point and a radius. |
isenclosedBy(self, points, wrap=False) Check whether a polygon or composite encloses this point. |
midpointTo(self, other, height=None, fraction=0.5, wrap=False) Find the midpoint on a geodesic between this and an other point. |
nearestOn(self, point1, point2, within=True, height=None, wrap=False, equidistant=None, tol=0.001) Iteratively locate the closest point on the geodesic between two other (ellipsoidal) points. |
parse(self, strllh, height=0, datum=None, epoch=None, reframe=None, sep=',', wrap=False, **name) Parse a string consisting of `"lat, lon[, height]"`, representing a similar, ellipsoidal `LatLon` point. |
to3xyz(self) DEPRECATED, use method `toEcef`. |
toCartesian(self, height=None, **Cartesian_and_kwds) Convert this point to cartesian, geocentric coordinates, also known as Earth-Centered, Earth-Fixed (ECEF). |
toCss(self, **toCss_kwds) Convert this `LatLon` point to a Cassini-Soldner location. |
toDatum(self, datum2, height=None, **name) Convert this point to an other datum. |
toEtm(self, **toEtm8_kwds) Convert this `LatLon` point to an ETM coordinate. |
toLcc(self, **toLcc_kwds) Convert this `LatLon` point to a Lambert location. |
toMgrs(self, center=False, pole='') Convert this `LatLon` point to an MGRS coordinate. |
toOsgr(self, kTM=False, **toOsgr_kwds) Convert this `LatLon` point to an OSGR coordinate. |
toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, height=None, **name) Convert this point to an other reference frame and epoch. |
toTransform(self, transform, inverse=False, datum=None, **LatLon_kwds) Apply a Helmert transform to this geodetic point. |
toUps(self, pole='', falsed=True, center=False) Convert this `LatLon` point to a UPS coordinate. |
toUtm(self, center=False) Convert this `LatLon` point to a UTM coordinate. |
toUtmUps(self, pole='', center=False) Convert this `LatLon` point to a UTM or UPS coordinate. |
triangulate(self, bearing1, other, bearing2, **height_wrap_tol) Iteratively locate a point given this, an other point and the (initial) bearing at this and at the other point. |
trilaterate5(self, distance1, point2, distance2, point3, distance3, area=True, eps=0.9999999999999998, wrap=False) Trilaterate three points by area overlap or perimeter intersection of three intersecting circles. |
Inherited from `latlonBase.LatLonBase`: `PointsIter`, `__eq__`, `__ne__`, `__str__`, `bounds`, `boundsOf`, `chordTo`, `circin6`, `circum3`, `circum4_`, `compassAngle`, `compassAngleTo`, `cosineAndoyerLambertTo`, `cosineForsytheAndoyerLambertTo`, `cosineLawTo`, `destinationXyz`, `equals`, `equals3`, `equirectangularTo`, `euclideanTo`, `flatLocalTo`, `flatPolarTo`, `hartzell`, `haversineTo`, `height4`, `heightStr`, `hubenyTo`, `intersecant2`, `isantipode`, `isantipodeTo`, `isequalTo`, `isequalTo3`, `latlon2`, `latlon2round`, `latlon_`, `nearestOn6`, `nearestTo`, `normal`, `philam2`, `points`, `points2`, `radii11`, `rhumbAzimuthTo`, `rhumbDestination`, `rhumbDistanceTo`, `rhumbIntersecant2`, `rhumbLine`, `rhumbMidpointTo`, `thomasTo`, `to2ab`, `to3llh`, `toEcef`, `toLocal`, `toLtp`, `toNormal`, `toNvector`, `toStr`, `toVector`, `toVector3d`, `toWm`, `vincentysTo` 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
| Equidistant Get the prefered azimuthal equidistant projection class (EquidistantKarney or EquidistantExact).
| convergence DEPRECATED, use property `gamma`.
| datum Class `property` with retrievable name.
| ellipsoidalLatLon Get this `LatLon`'s ellipsoidal class.
| epoch Class `property` with retrievable name.
| gamma Get this point's UTM or UPS meridian convergence (`degrees`) or `None` if not available or not converted from Utm or Ups.
| iteration Get the most recent `intersections2` or `nearestOn` iteration number (`int`) or `None` if not available/applicable.
| reframe Class `property` with retrievable name.
| scale Get this point's UTM grid or UPS point scale factor (`float`) or `None` if not converted from Utm or Ups.
Inherited from `latlonBase.LatLonBase`: `Ecef`, `clipid`, `height`, `isEllipsoidal`, `isSpherical`, `isnormal`, `lam`, `lat`, `latlon`, `latlonheight`, `lon`, `phi`, `philam`, `philamheight`, `sphericalLatLon`, `xyz`, `xyzh` Inherited from `named._Named`: `classname`, `classnaming`, `name`, `named`, `named2`, `named3`, `named4`, `sizeof` Inherited from `object`: `__class__`

Method Details

### __init__ (self, latlonh, lon=None, height=0, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran`...`, reframe=None, epoch=None, wrap=False, **name) (Constructor) |
Create an ellipsoidal `LatLon` point from the given lat-, longitude and height on the given datum, reference frame and epoch. 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`, same units as the datum's ellipsoid axes). `datum` - Optional, ellipsoidal datum to use (Datum, Ellipsoid, Ellipsoid2 or a_f2Tuple). `reframe` - Optional reference frame (RefFrame). `epoch` - Optional epoch to observe for `reframe` (`scalar`), a non-zero, fractional calendar year, but silently ignored if `reframe=None`. `wrap` - If `True`, wrap or normalize `lat` and `lon` (`bool`). `name` - Optional `name=NN` (`str`). Returns: New instance (`LatLon`). Raises: `RangeError` - Value of `lat` or `lon` outside the valid range and rangerrors set to `True`. `TypeError` - If `latlonh` is not a `LatLon`, `datum` is not a Datum, `reframe` is not a RefFrame or `epoch` is not `scalar` non-zero. `UnitError` - Invalid `lat`, `lon` or `height`. Overrides: object.__init__

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

### convertDatum (self, datum2) |
DEPRECATED, use method toDatum. Decorators: `@deprecated_method`

### convertRefFrame (self, reframe2) |
DEPRECATED, use method toRefFrame. Decorators: `@deprecated_method`

### distanceTo2 (self, other, wrap=False) |
Approximate the distance and (initial) bearing between this and an other (ellipsoidal) point based on the radii of curvature. Suitable only for short distances up to a few hundred Km or Miles and only between points not near-polar. Arguments: `other` - The other point (`LatLon`). `wrap` - If `True`, wrap or normalize the `other` point (`bool`). Returns: An Distance2Tuple`(distance, initial)`. Raises: `TypeError` - The `other` point is not `LatLon`. `ValueError` - Incompatible datum ellipsoids. See Also: Method Ellipsoid.distance2 and Local, flat earth approximation aka Hubeny formula.

### elevation2 (self, adjust=True, datum=None, timeout=2) |
Return elevation of this point for its or the given datum, ellipsoid or sphere. Arguments: `adjust` - Adjust the elevation for a `datum` other than `NAD83` (`bool`). `datum` - Optional datum overriding this point's datum (Datum, Ellipsoid, Ellipsoid2, a_f2Tuple or `scalar` radius). `timeout` - Optional query timeout (`seconds`). Returns: An Elevation2Tuple`(elevation, data_source)` or `(None, error)` in case of errors. Notes: The adjustment applied is the difference in geocentric earth radius between the `datum` and `NAV83` upon which the elevations.elevation2 is based. NED elevation is only available for locations within the Conterminous US (CONUS). See Also: Function elevations.elevation2 and method `Ellipsoid.Rgeocentric` for further details and possible `error`s.

### ellipsoid (self, datum=Datum(name='WGS84', ellipsoid=Ellipsoids.WGS84, transform=Tran`...`) |
Return the ellipsoid of this point's datum or the given datum. Arguments: `datum` - Default datum (Datum). Returns: The ellipsoid (Ellipsoid or Ellipsoid2).

### ellipsoids (self, other) |
Check the type and ellipsoid of this and an other point's datum. Arguments: `other` - The other point (`LatLon`). Returns: This point's datum ellipsoid (Ellipsoid or Ellipsoid2). Raises: `TypeError` - The `other` point is not `LatLon`. `ValueError` - Incompatible datum ellipsoids.

### geoidHeight2 (self, adjust=False, datum=None, timeout=2) |
Return geoid height of this point for its or the given datum, ellipsoid or sphere. Arguments: `adjust` - Adjust the geoid height for a `datum` other than `NAD83/NADV88` (`bool`). `datum` - Optional datum overriding this point's datum (Datum, Ellipsoid, Ellipsoid2, a_f2Tuple or `scalar` radius). `timeout` - Optional query timeout (`seconds`). Returns: A GeoidHeight2Tuple`(height, model_name)` or `(None, error)` in case of errors. Notes: The adjustment applied is the difference in geocentric earth radius between the `datum` and `NAV83/NADV88` upon which the elevations.geoidHeight2 is based. The geoid height is only available for locations within the Conterminous US (CONUS). See Also: Function elevations.geoidHeight2 and method `Ellipsoid.Rgeocentric` for further details and possible `error`s.

### intersection3 (self, end1, other, end2, height=None, wrap=False, equidistant=None, tol=0.001) |
Iteratively compute the intersection point of two lines, each defined by two points or a start point and bearing from North. Arguments: `end1` - End point of this line (`LatLon`) or the initial bearing at this point (compass `degrees360`). `other` - Start point of the other line (`LatLon`). `end2` - End point of the other line (`LatLon`) or the initial bearing at the other point (compass `degrees360`). `height` - Optional height at the intersection (`meter`, conventionally) or `None` for the mean height. `wrap` - If `True`, wrap or normalize and unroll the `other` and `end*` points (`bool`). `equidistant` - An azimuthal equidistant projection (class or function pygeodesy.equidistant), or `None` for this point's preferred `.Equidistant`. `tol` - Tolerance for convergence and skew line distance and length (`meter`, conventionally). Returns: An Intersection3Tuple`(point, outside1, outside2)` with `point` a `LatLon` instance. Raises: `ImportError` - Package geographiclib not installed or not found, but only if `equidistant=`EquidistantKarney. `IntersectionError` - Skew, colinear, parallel or otherwise non-intersecting lines or no convergence for the given `tol`. `TypeError` - If `end1`, `other` or `end2` point is not `LatLon`. Note: For each line specified with an initial bearing, a pseudo-end point is computed as the `destination` along that bearing at about 1.5 times the distance from the start point to an initial gu-/estimate of the intersection point (and between 1/8 and 3/8 of the authalic earth perimeter). See Also: Karney's intersect.cpp, The ellipsoidal case and Karney's paper, pp 20-21, section 14. MARITIME BOUNDARIES for more details about the iteration algorithm.

### intersections2 (self, radius1, other, radius2, height=None, wrap=False, equidistant=None, tol=0.001) |
Iteratively compute the intersection points of two circles, each defined by a center point and a radius. Arguments: `radius1` - Radius of this circle (`meter`, conventionally). `other` - Center of the other circle (`LatLon`). `radius2` - Radius of the other circle (`meter`, same units as `radius1`). `height` - Optional height for the intersection points (`meter`, conventionally) or `None` for the "radical height" at the radical line between both centers. `wrap` - If `True`, wrap or normalize and unroll the `other` center (`bool`). `equidistant` - An azimuthal equidistant projection (class or function pygeodesy.equidistant) or `None` for this point's preferred `.Equidistant`. `tol` - Convergence tolerance (`meter`, same units as `radius1` and `radius2`). Returns: 2-Tuple of the intersection points, each a `LatLon` instance. For abutting circles, both intersection points are the same instance, aka the radical center. Raises: `ImportError` - Package geographiclib not installed or not found, but only if `equidistant=`EquidistantKarney. `IntersectionError` - Concentric, antipodal, invalid or non-intersecting circles or no convergence for the given `tol`. `TypeError` - Invalid `other` or `equidistant`. `UnitError` - Invalid `radius1`, `radius2` or `height`. See Also: The ellipsoidal case, Karney's paper, pp 20-21, section 14. MARITIME BOUNDARIES, circle-circle and sphere-sphere intersections.

### isenclosedBy (self, points, wrap=False) |
Check whether a polygon or composite encloses this point. Arguments: `points` - The polygon points or clips (`LatLon`[], BooleanFHP or BooleanGH). `wrap` - If `True`, wrap or normalize and unroll the `points` (`bool`). Returns: `True` if this point is inside the polygon or composite, `False` otherwise. Raises: `PointsError` - Insufficient number of `points`. `TypeError` - Some `points` are not `LatLon`. `ValueError` - Invalid `point`, lat- or longitude. See Also: Functions pygeodesy.isconvex, pygeodesy.isenclosedBy and pygeodesy.ispolar especially if the `points` may enclose a pole or wrap around the earth longitudinally.

### midpointTo (self, other, height=None, fraction=0.5, wrap=False) |
Find the midpoint on a geodesic between this and an other point. Arguments: `other` - The other point (`LatLon`). `height` - Optional height for midpoint, overriding the mean height (`meter`). `fraction` - Midpoint location from this point (`scalar`), may be negative or greater than 1.0. `wrap` - If `True`, wrap or normalize and unroll the `other` point (`bool`). Returns: Midpoint (`LatLon`). Raises: `TypeError` - The `other` point is not `LatLon`. `ValueError` - Invalid `height`. See Also: Methods `intermediateTo` and `rhumbMidpointTo`.

### nearestOn (self, point1, point2, within=True, height=None, wrap=False, equidistant=None, tol=0.001) |
Iteratively locate the closest point on the geodesic between two other (ellipsoidal) points. Arguments: `point1` - Start point (`LatLon`). `point2` - End point (`LatLon`). `within` - If `True` return the closest point between `point1` and `point2`, otherwise the closest point elsewhere on the geodesic (`bool`). `height` - Optional height for the closest point (`meter`, conventionally) or `None` or `False` for the interpolated height. If `False`, the closest takes the heights of the points into account. `wrap` - If `True`, wrap or normalize and unroll both `point1` and `point2` (`bool`). `equidistant` - An azimuthal equidistant projection (class or function pygeodesy.equidistant) or `None` for this point's preferred `.Equidistant`. `tol` - Convergence tolerance (`meter`, conventionally). Returns: Closest point (`LatLon`). Raises: `ImportError` - Package geographiclib not installed or not found, but only if `equidistant=`EquidistantKarney. `TypeError` - Invalid `point1`, `point2` or `equidistant`. `ValueError` - Datum or ellipsoid of `point1` or `point2` is incompatible or no convergence for the given `tol`. See Also: Karney's intercept.cpp, The ellipsoidal case and Karney's paper, pp 20-21, section 14. MARITIME BOUNDARIES for details about the iteration algorithm.

### parse (self, strllh, height=0, datum=None, epoch=None, reframe=None, sep=',', wrap=False, **name) |
Parse a string consisting of `"lat, lon[, height]"`, representing a similar, ellipsoidal `LatLon` point. Arguments: `strllh` - Lat, lon and optional height (`str`), see function pygeodesy.parse3llh. `height` - Optional, default height (`meter` or `None`). `datum` - Optional datum (Datum), overriding this datum without conversion. `epoch` - Optional datum (Epoch), overriding this epoch without conversion. `reframe` - Optional datum (RefFrame), overriding this reframe without conversion. `sep` - Optional separator (`str`). `wrap` - If `True`, wrap or normalize the lat- and longitude (`bool`). `name` - Optional `name=NN` (`str`), overriding this name. Returns: The similar point (ellipsoidal `LatLon`). Raises: `ParseError` - Invalid `strllh`.

### to3xyz (self) |
DEPRECATED, use method `toEcef`. Returns: A Vector3Tuple`(x, y, z)`. Decorators: `@deprecated_method` Overrides: latlonBase.LatLonBase.to3xyz Note: Overloads `LatLonBase.to3xyz`

### toCartesian (self, height=None, **Cartesian_and_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`. Overrides: latlonBase.LatLonBase.toCartesian See Also: Method toCartesian for further details.

### toCss (self, **toCss_kwds) |
Convert this `LatLon` point to a Cassini-Soldner location. Arguments: `toCss_kwds` - Optional pygeodesy.toCss keyword arguments. Returns: The Cassini-Soldner location (Css). See Also: Function pygeodesy.toCss.

### toDatum (self, datum2, height=None, **name) |
Convert this point to an other datum. Arguments: `datum2` - Datum to convert to (Datum). `height` - Optional height, overriding the converted height (`meter`). `name` - Optional `name=NN` (`str`). Returns: The converted point (ellipsoidal `LatLon`) or a copy of this point if `datum2` matches this point's `datum`. Raises: `TypeError` - Invalid `datum2`. Overrides: latlonBase.LatLonBase.toDatum

### toEtm (self, **toEtm8_kwds) |
Convert this `LatLon` point to an ETM coordinate. Arguments: `toEtm8_kwds` - Optional pygeodesy.toEtm8 keyword arguments. Returns: The ETM coordinate (Etm). See Also: Function pygeodesy.toEtm8.

### toLcc (self, **toLcc_kwds) |
Convert this `LatLon` point to a Lambert location. Arguments: `toLcc_kwds` - Optional pygeodesy.toLcc keyword arguments. Returns: The Lambert location (Lcc). See Also: Function pygeodesy.toLcc.

### toMgrs (self, center=False, pole='') |
Convert this `LatLon` point to an MGRS coordinate. Arguments: `center` - If `True`, try to un-center MGRS to its `lowerleft` (`bool`) or by `center meter` (`scalar`). `pole` - Optional top/center for the MGRS UPS projection (`str`, 'N[orth]' or 'S[outh]'). Returns: The MGRS coordinate (Mgrs). See Also: Method toUtmUps and Mgrs.toLatLon.

### toOsgr (self, kTM=False, **toOsgr_kwds) |
Convert this `LatLon` point to an OSGR coordinate. Arguments: `kTM` - If `True` use Karney's Krüger method from module ktm, otherwise Ordinance Survery's recommended formulation (`bool`). `toOsgr_kwds` - Optional pygeodesy.toOsgr keyword arguments. Returns: The OSGR coordinate (Osgr). See Also: Function pygeodesy.toOsgr.

### toRefFrame (self, reframe2, reframe=None, epoch=None, epoch2=None, height=None, **name) |
Convert this point to an other reference frame and epoch. Arguments: `reframe2` - Reference frame to convert to (RefFrame). `reframe` - Optional reference frame to convert from (RefFrame), overriding this point's reference frame. `epoch` - Optional epoch (Epoch, `scalar` or `str`), overriding this point's `epoch or reframe.epoch`. `epoch2` - Optional epoch to observe for the converted point (Epoch, `scalar` or `str`), otherwise `epoch`. `height` - Optional height, overriding the converted height (`meter`). `name` - Optional `name=NN` (`str`), overriding `reframe2.name`. Returns: The converted point (ellipsoidal `LatLon`) or if conversion `isunity`, this point or a copy of this point if the `name` is non-empty. Raises: `TRFError` - This point's `reframe` is not defined, invalid `epoch` or `epoch2` or conversion from this point's `reframe` to `reframe2` is not available. `TypeError` - `reframe2` or `reframe` not a RefFrame.

### toTransform (self, transform, inverse=False, datum=None, **LatLon_kwds) |
Apply a Helmert transform to this geodetic point. Arguments: `transform` - Transform to apply (Transform or TransformXform). `inverse` - Apply the inverse of the Helmert transform (`bool`). `datum` - Datum for the transformed point (Datum), overriding this point's datum but not taken it into account. `LatLon_kwds` - Optional keyword arguments for the transformed point, like `height=...`. Returns: A transformed point (`LatLon`) or a copy of this point if `transform.isunity`. Raises: `TypeError` - Invalid `transform`.

### toUps (self, pole='', falsed=True, center=False) |
Convert this `LatLon` point to a UPS coordinate. Arguments: `pole` - Optional top/center of (stereographic) projection (`str`, 'N[orth]' or 'S[outh]'). `falsed` - False easting and northing (`bool`). `center` - If `True`, un-center the UPS to its `lowerleft` (`bool`) or by `center meter` (`scalar`). Returns: The UPS coordinate (Ups). See Also: Function pygeodesy.toUps8.

### toUtm (self, center=False) |
Convert this `LatLon` point to a UTM coordinate. Arguments: `center` - If `True`, un-center the UTM to its `lowerleft` (`bool`) or by `center meter` (`scalar`). Returns: The UTM coordinate (Utm). See Also: Method Mgrs.toUtm and function pygeodesy.toUtm8.

### toUtmUps (self, pole='', center=False) |
Convert this `LatLon` point to a UTM or UPS coordinate. Arguments: `pole` - Optional top/center of UPS (stereographic) projection (`str`, 'N[orth]' or 'S[outh]'). `center` - If `True`, un-center the UTM or UPS to its `lowerleft` (`bool`) or by `center meter` (`scalar`). Returns: The UTM or UPS coordinate (Utm or Ups). See Also: Function pygeodesy.toUtmUps8.

### triangulate (self, bearing1, other, bearing2, **height_wrap_tol) |
Iteratively locate a point given this, an other point and the (initial) bearing at this and at the other point. Arguments: `bearing1` - Bearing at this point (compass `degrees360`). `other` - Start point of the other line (`LatLon`). `bearing2` - Bearing at the other point (compass `degrees360`). `height_wrap_tol` - Optional keyword arguments `height=None`, `wrap=False` and `tol`, see method intersection3. Returns: Triangulated point (`LatLon`). See Also: Method intersection3 for further details.

### trilaterate5 (self, distance1, point2, distance2, point3, distance3, area=True, eps=0.9999999999999998, wrap=False) |
Trilaterate three points by area overlap or perimeter intersection of three intersecting circles. Arguments: `distance1` - Distance to this point (`meter`), same units as `eps`). `point2` - Second center point (`LatLon`). `distance2` - Distance to point2 (`meter`, same units as `eps`). `point3` - Third center point (`LatLon`). `distance3` - Distance to point3 (`meter`, same units as `eps`). `area` - If `True` compute the area overlap, otherwise the perimeter intersection of the circles (`bool`). `eps` - The required minimal overlap for `area=True` or the intersection margin for `area=False` (`meter`, conventionally). `wrap` - If `True`, wrap or normalize and unroll `point2` and `point3` (`bool`). Returns: A Trilaterate5Tuple`(min, minPoint, max, maxPoint, n)` with `min` and `max` in `meter`, same units as `eps`, the corresponding trilaterated points `minPoint` and `maxPoint` as ellipsoidal `LatLon` and `n`, the number of trilatered points found for the given `eps`. If only a single trilaterated point is found, `min is max`, `minPoint is maxPoint` and `n = 1`. For `area=True`, `min` and `max` are the smallest respectively largest radial overlap found. For `area=False`, `min` and `max` represent the nearest respectively farthest intersection margin. If `area=True` and all 3 circles are concentric, `n=0` and `minPoint` and `maxPoint` are the `point#` with the smallest `distance#` `min` respectively `max` the largest `distance#`. Raises: `IntersectionError` - Trilateration failed for the given `eps`, insufficient overlap for `area=True`, no circle intersections for `area=False` or all circles are (near-)concentric. `TypeError` - Invalid `point2` or `point3`. `ValueError` - Coincident `points` or invalid `distance1`, `distance2` or `distance3`. Note: Ellipsoidal trilateration invokes methods `LatLon.intersections2` and `LatLon.nearestOn` based on Karney's Python geographiclib if installed, otherwise the accurate (but slower) `ellipsoidalExact.LatLon` methods.

Property Details

### Equidistant Get the prefered azimuthal equidistant projection class (EquidistantKarney or EquidistantExact). Get method: Equidistant(self) - Get the prefered azimuthal equidistant projection class (EquidistantKarney or EquidistantExact). Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

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

### datum Class `property` with retrievable name. Get method: datum(self) - Get this point's datum (Datum). Set method: datum(self, datum) - Set this point's datum without conversion (Datum).

### ellipsoidalLatLon Get this `LatLon`'s ellipsoidal class. Get method: ellipsoidalLatLon(self) - Get this `LatLon`'s ellipsoidal class. Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### epoch Class `property` with retrievable name. Get method: epoch(self) - Get this point's observed or `reframe` epoch (Epoch) or `None`. Set method: epoch(self, epoch) - Set or clear this point's observed epoch, a fractional calendar year (Epoch, `scalar` or `str`) or `None`.

### gamma Get this point's UTM or UPS meridian convergence (`degrees`) or `None` if not available or not converted from Utm or Ups. Get method: gamma(self) - Get this point's UTM or UPS meridian convergence (`degrees`) or `None` if not available or not converted from Utm or Ups. Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### iteration Get the most recent `intersections2` or `nearestOn` iteration number (`int`) or `None` if not available/applicable. Get method: iteration(self) - Get the most recent `intersections2` or `nearestOn` iteration number (`int`) or `None` if not available/applicable. Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.

### reframe Class `property` with retrievable name. Get method: reframe(self) - Get this point's reference frame (RefFrame) or `None`. Set method: reframe(self, reframe) - Set or clear this point's reference frame (RefFrame) or `None`.

### scale Get this point's UTM grid or UPS point scale factor (`float`) or `None` if not converted from Utm or Ups. Get method: scale(self) - Get this point's UTM grid or UPS point scale factor (`float`) or `None` if not converted from Utm or Ups. Set method: _fset_error(inst, val) - Throws an `AttributeError`, always. Delete Method: _fdel(inst) - Zap the cached/memoized `property` value.