def __init__(self, easting, northing, band='', datum=None, falsed=True,
convergence=None, scale=None):
'''(INTERNAL) New L{UtmUpsBase}.
'''
E = self._Error
if not E:
notOverloaded(self, '_Error')
self._easting = Easting(easting, Error=E)
self._northing = Northing(northing, Error=E)
if band:
_xinstanceof(str, band=band)
self._band = band
if datum:
_xinstanceof(Datum, datum=datum)
if datum != self._datum:
self._datum = datum
if not falsed:
self._falsed = False
if convergence is not self._convergence:
self._convergence = Scalar(convergence, name='convergence', Error=E)
if scale is not self._scale:
self._scale = Scalar(scale, name='scale', Error=E)
def __init__(self,
easting,
northing,
band=NN,
datum=None,
falsed=True,
convergence=None,
scale=None):
'''(INTERNAL) New L{UtmUpsBase}.
'''
E = self._Error
if not E:
notOverloaded(self, '_Error')
self._easting = Easting(easting, Error=E)
self._northing = Northing(northing, Error=E)
if band:
_xinstanceof(str, band=band)
self._band = band
if datum not in (None, self._datum):
self._datum = _ellipsoidal_datum(datum) # XXX name=band
if not falsed:
self._falsed = False
if convergence is not self._convergence:
self._convergence = Scalar(convergence,
name=_convergence_,
Error=E)
if scale is not self._scale:
self._scale = Scalar(scale, name=_scale_, Error=E)
def __init__(self, e, n, h=0, cs0=_CassiniSoldner0, name=NN):
'''New L{Css} Cassini-Soldner position.
@arg e: Easting (C{meter}).
@arg n: Northing (C{meter}).
@kwarg h: Optional height (C{meter}).
@kwarg cs0: Optional, the Cassini-Soldner projection
(L{CassiniSoldner}).
@kwarg name: Optional name (C{str}).
@return: The Cassini-Soldner location (L{Css}).
@raise CSSError: If B{C{e}} or B{C{n}} is invalid.
@raise ImportError: Package U{GeographicLib<https://PyPI.org/
project/geographiclib>} missing.
@raise TypeError: If B{C{cs0}} is not L{CassiniSoldner}.
@raise ValueError: Invalid B{C{h}}.
@example:
>>> cs = Css(448251, 5411932.0001)
'''
self._cs0 = _CassiniSoldner(cs0)
self._easting = Easting(e, Error=CSSError)
self._northing = Northing(n, Error=CSSError)
if h:
self._height = Height(h, name=_h_)
if name:
self.name = name
def __init__(self, e, n, h=0, conic=Conics.WRF_Lb, name=''):
'''New L{Lcc} Lamber conformal conic position.
@arg e: Easting (C{meter}).
@arg n: Northing (C{meter}).
@kwarg h: Optional height (C{meter}).
@kwarg conic: Optional, the conic projection (L{Conic}).
@kwarg name: Optional name (C{str}).
@return: The Lambert location (L{Lcc}).
@raise LCCError: Invalid B{C{h}} or invalid or
negative B{C{e}} or B{C{n}}.
@raise TypeError: If B{C{conic}} is not L{Conic}.
@example:
>>> lb = Lcc(448251, 5411932.0001)
'''
_xinstanceof(Conic, conic=conic)
self._conic = conic
self._easting = Easting(e, falsed=conic.E0 > 0, Error=LCCError)
self._northing = Northing(n, falsed=conic.N0 > 0, Error=LCCError)
if h:
self._height = Height(h, name='h', Error=LCCError)
if name:
self.name = name
def __init__(self, easting, northing, datum=None, name=NN):
'''New L{Osgr} National Grid Reference.
@arg easting: Easting from OS false easting (C{meter}).
@arg northing: Northing from from OS false northing (C{meter}).
@kwarg datum: Default datum (C{Datums.OSGB36}).
@kwarg name: Optional name (C{str}).
@raise OSGRError: Invalid or negative B{C{easting}} or
B{C{northing}} or B{C{datum}} not
C{Datums.OSBG36}.
@example:
>>> from pygeodesy import Osgr
>>> r = Osgr(651409, 313177)
'''
self._easting = Easting(easting, Error=OSGRError, osgr=True)
self._northing = Northing(northing, Error=OSGRError, osgr=True)
if datum not in (None, _Datums_OSGB36):
try:
if _ellipsoidal_datum(datum) != _Datums_OSGB36:
raise ValueError
except (TypeError, ValueError):
raise OSGRError(datum=datum)
if name:
self.name = name
def __new__(cls, z, h, e, n, B, d, c, s, Error=None):
if Error is not None:
e = Easting(e, Error=Error)
n = Northing(n, Error=Error)
c = Scalar(c, name=_convergence_, Error=Error)
s = Scalar(s, name=_scale_, Error=Error)
return _NamedTuple.__new__(cls, z, h, e, n, B, d, c, s)
def __new__(cls, z, h, e, n, B, d, c, s, Error=None):
if Error is not None:
e = Easting(e, Error=Error)
n = Northing(n, Error=Error)
c = Degrees(convergence=c, Error=Error)
s = Scalar(scale=s, Error=Error)
return _NamedTuple.__new__(cls, z, h, e, n, B, d, c, s)
def __init__(self,
latlon0,
par1,
par2=None,
E0=0,
N0=0,
k0=1,
opt3=0,
name='',
auth=''):
'''New Lambert conformal conic projection.
@arg latlon0: Origin with (ellipsoidal) datum (C{LatLon}).
@arg par1: First standard parallel (C{degrees90}).
@kwarg par2: Optional, second standard parallel (C{degrees90}).
@kwarg E0: Optional, false easting (C{meter}).
@kwarg N0: Optional, false northing (C{meter}).
@kwarg k0: Optional scale factor (C{scalar}).
@kwarg opt3: Optional meridian (C{degrees180}).
@kwarg name: Optional name of the conic (C{str}).
@kwarg auth: Optional authentication authority (C{str}).
@return: A Lambert projection (L{Conic}).
@raise TypeError: Non-ellipsoidal B{C{latlon0}}.
@raise ValueError: Invalid B{C{par1}}, B{C{par2}},
B{C{E0}}, B{C{N0}}, B{C{k0}}
or B{C{opt3}}.
@example:
>>> from pygeodesy import Conic, Datums, ellipsoidalNvector
>>> ll0 = ellipsoidalNvector.LatLon(23, -96, datum=Datums.NAD27)
>>> Snyder = Conic(ll0, 33, 45, E0=0, N0=0, name='Snyder')
'''
if latlon0 is not None:
_xinstanceof(_LLEB, latlon0=latlon0)
self._phi0, self._lam0 = latlon0.philam
self._par1 = Phi_(par1, name='par1')
self._par2 = self._par1 if par2 is None else Phi_(par2,
name='par2')
if k0 != 1:
self._k0 = Scalar_(k0, name='k0')
if E0:
self._E0 = Northing(E0, name='E0', falsed=True)
if N0:
self._N0 = Easting(N0, name='N0', falsed=True)
if opt3:
self._opt3 = Lam_(opt3, name='opt3')
self.toDatum(latlon0.datum)._dup2(self)
self._register(Conics, name)
elif name:
self._name = name
if auth:
self._auth = auth
def __init__(self,
zone,
en100k,
easting,
northing,
band=NN,
datum=Datums.WGS84,
name=NN):
'''New L{Mgrs} Military grid reference.
@arg zone: 6° longitudinal zone (C{int}), 1..60 covering 180°W..180°E.
@arg en100k: Two-letter EN digraph (C{str}), 100 km grid square.
@arg easting: Easting (C{meter}), within 100 km grid square.
@arg northing: Northing (C{meter}), within 100 km grid square.
@kwarg band: Optional 8° latitudinal band (C{str}), C..X covering 80°S..84°N.
@kwarg datum: Optional this reference's datum (L{Datum}, L{Ellipsoid},
L{Ellipsoid2} or L{a_f2Tuple}).
@kwarg name: Optional name (C{str}).
@raise MGRSError: Invalid MGRS grid reference, B{C{zone}}, B{C{en100k}},
B{C{easting}}, B{C{northing}} or B{C{band}}.
@raise TypeError: Invalid B{C{datum}}.
@example:
>>> from pygeodesy import Mgrs
>>> m = Mgrs('31U', 'DQ', 48251, 11932) # 31U DQ 48251 11932
'''
if name:
self.name = name
self._zone, self._band, self._bandLat = _to3zBlat(
zone, band, MGRSError)
try:
en = str(en100k).upper()
if len(en) != 2:
raise IndexError # caught below
self._en100k = en
self._en100k2m()
except IndexError:
raise MGRSError(en100k=en100k)
self._easting = Easting(easting, Error=MGRSError)
self._northing = Northing(northing, Error=MGRSError)
if datum not in (None, self._datum):
self._datum = _ellipsoidal_datum(datum, name=name)
def forward(self, lat, lon):
'''Convert an (ellipsoidal) geodetic location to Cassini-Soldner
easting and northing.
@arg lat: Latitude of the location (C{degrees90}).
@arg lon: Longitude of the location (C{degrees180}).
@return: An L{EasNor2Tuple}C{(easting, northing)}.
@see: Methods L{CassiniSoldner.forward4}, L{CassiniSoldner.reverse}
and L{CassiniSoldner.reverse4}.
'''
e, n = self.forward4(lat, lon)[:2]
r = EasNor2Tuple(Easting(e, Error=CSSError), Northing(n,
Error=CSSError))
return self._xnamed(r)
def eastingnorthing2(self, falsed=True):
'''Return easting and northing, falsed or unfalsed.
@kwarg falsed: Return easting and northing falsed
(C{bool}), otherwise unfalsed.
@return: An L{EasNor2Tuple}C{(easting, northing)} in C{meter}s.
'''
e, n = self.falsed2
if self.falsed and not falsed:
e, n = -e, -n
elif falsed and not self.falsed:
pass
else:
e = n = 0
return EasNor2Tuple(Easting(e + self.easting, Error=self._Error),
Northing(n + self.northing, Error=self._Error))
def __init__(self, easting, northing, name=''):
'''New L{Osgr} National Grid Reference.
@arg easting: Easting from OS false easting (C{meter}).
@arg northing: Northing from from OS false northing (C{meter}).
@kwarg name: Optional name (C{str}).
@raise OSGRError: Invalid or negative B{C{easting}} or
B{C{northing}}.
@example:
>>> from pygeodesy import Osgr
>>> r = Osgr(651409, 313177)
'''
if name:
self.name = name
self._easting = Easting(easting, Error=OSGRError)
self._northing = Northing(northing, Error=OSGRError)
def __init__(self, x, y, radius=R_MA, name=NN):
'''New L{Wm} Web Mercator (WM) coordinate.
@arg x: Easting from central meridian (C{meter}).
@arg y: Northing from equator (C{meter}).
@kwarg radius: Optional earth radius (C{meter}).
@kwarg name: Optional name (C{str}).
@raise WebMercatorError: Invalid B{C{x}}, B{C{y}} or B{C{radius}}.
@example:
>>> import pygeodesy
>>> w = pygeodesy.Wm(448251, 5411932)
'''
self._x = Easting(x=x, Error=WebMercatorError)
self._y = Northing(y=y, Error=WebMercatorError)
self._radius = Radius_(radius, Error=WebMercatorError)
if name:
self.name = name
def _EasNor2Tuple(e, n):
'''(INTERNAL) Helper for L{parseOSGR} and L{toOsgr}.
'''
return EasNor2Tuple(Easting(e, Error=OSGRError),
Northing(n, Error=OSGRError))
def __new__(cls, e, n, r):
return _NamedTuple.__new__(cls, Easting(e, Error=WebMercatorError),
Northing(n, Error=WebMercatorError),
Radius(r, Error=WebMercatorError))
_NamedBase, nameof, _xnamed
from pygeodesy.streprs import enstr2
from pygeodesy.units import Easting, Lam_, Northing, Phi_, Scalar
from pygeodesy.utily import degrees90, degrees180, sincos2
from math import cos, radians, sin, sqrt, tan
__all__ = _ALL_LAZY.osgr
__version__ = '20.09.01'
_10um = 1e-5 #: (INTERNAL) 0.01 millimeter (C{meter})
_100km = 100000 #: (INTERNAL) 100 km (int meter)
_A0 = Phi_(49) #: (INTERNAL) NatGrid true origin latitude, 49°N.
_B0 = Lam_(-2) #: (INTERNAL) NatGrid true origin longitude, 2°W.
_E0 = Easting(400e3) #: (INTERNAL) Easting of true origin (C{meter}).
_N0 = Northing(-100e3) #: (INTERNAL) Northing of true origin (C{meter}).
_F0 = Scalar(
0.9996012717) #: (INTERNAL) NatGrid scale of central meridian (C{float}).
_Datums_OSGB36 = Datums.OSGB36 #: (INTERNAL) Airy130 ellipsoid
_latlon_ = 'latlon'
_no_convertDatum_ = 'no .convertDatum'
_ord_A = ord('A')
_TRIPS = 33 #: (INTERNAL) .toLatLon convergence
def _ll2datum(ll, datum, name):
'''(INTERNAL) Convert datum if needed.
'''
if datum not in (None, ll.datum):
def __new__(cls, e, n, azi, rk):
return _NamedTuple.__new__(cls, Easting(e, Error=CSSError),
Northing(n, Error=CSSError),
Bearing(azi, Error=CSSError),
Scalar(rk, Error=CSSError))
def __new__(cls, z, di, e, n, Error=MGRSError):
if Error is not None:
e = Easting(e, Error=Error)
n = Northing(n, Error=Error)
return _NamedTuple.__new__(cls, z, di, e, n)
def __new__(cls, z, h, e, n, B, Error=None):
if Error is not None:
e = Easting(e, Error=Error)
n = Northing(n, Error=Error)
return _NamedTuple.__new__(cls, z, h, e, n, B)
