pygeodesy 24.5.15__py2.py3-none-any.whl → 24.6.1__py2.py3-none-any.whl

pygeodesy/utm.py

@@ -35,17 +35,16 @@ and Henrik Seidel U{'Die Mathematik der Gauß-Krueger-Abbildung'
 
 from pygeodesy.basics import len2, map2, neg  # splice
 from pygeodesy.constants import EPS, EPS0, _K0_UTM, _0_0, _0_0001
-from pygeodesy.datums import _ellipsoidal_datum, _WGS84
+from pygeodesy.datums import _ellipsoidal_datum, _WGS84,  _under
 from pygeodesy.dms import degDMS, parseDMS2
 from pygeodesy.errors import MGRSError, RangeError, _ValueError, \
-                            _xkwds_get
+                            _xkwds_get, _xkwds_pop2
 from pygeodesy.fmath import fdot3, hypot, hypot1,  _operator
-# from pygeodesy.internals import _under  # from .utmupsBase
+# from pygeodesy.internals import _under  # from .datums
 from pygeodesy.interns import MISSING, NN, _by_, _COMMASPACE_, _N_, \
                              _NS_, _outside_, _range_, _S_, _scale0_, \
                              _SPACE_, _UTM_, _V_, _X_, _zone_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
-# from pygeodesy.named import _xnamed  # from .utmupsBase
 from pygeodesy.namedTuples import EasNor2Tuple, UtmUps5Tuple, \
                                   UtmUps8Tuple, UtmUpsLatLon5Tuple
 from pygeodesy.props import deprecated_method, property_doc_, \
@@ -55,8 +54,8 @@ from pygeodesy.units import Band, Int, Lat, Lon, Meter, Zone
 from pygeodesy.utily import atan1, degrees90, degrees180, sincos2
 from pygeodesy.utmupsBase import _hemi, _LLEB, _parseUTMUPS5, _to4lldn, \
                                  _to3zBhp, _to3zll, _UPS_LATS, _UPS_ZONE, \
-                                 _UTM_LAT_MAX, _UTM_ZONE_MAX,  _under, \
-                                 _UTM_LAT_MIN, _UTM_ZONE_MIN,  _xnamed, \
+                                 _UTM_LAT_MAX, _UTM_ZONE_MAX, \
+                                 _UTM_LAT_MIN, _UTM_ZONE_MIN, \
                                  _UTM_ZONE_OFF_MAX, UtmUpsBase
 
 from math import asinh, atanh, atan2, cos, cosh, degrees, fabs, \
@@ -64,7 +63,7 @@ from math import asinh, atanh, atan2, cos, cosh, degrees, fabs, \
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.utm
-__version__ = '24.02.29'
+__version__ = '24.05.31'
 
 _Bands = 'CDEFGHJKLMNPQRSTUVWXX'  # UTM latitude bands C..X (no
 # I|O) 8° each, covering 80°S to 84°N and X repeated for 80-84°N
@@ -134,120 +133,6 @@ class _Kseries(object):
         return fdot3(self._pq, self._sy, self._shx, start=q0)
 
 
-def _cmlon(zone):
-    '''(INTERNAL) Central meridian longitude (C{degrees180}).
-    '''
-    return (zone * 6) - 183
-
-
-def _false2(e, n, h):
-    '''(INTERNAL) False easting and northing.
-    '''
-    # Karney, "Test data for the transverse Mercator projection (2009)"
-    # <https://GeographicLib.SourceForge.io/C++/doc/transversemercator.html>
-    # and <https://Zenodo.org/record/32470#.W4LEJS2ZON8>
-    e += _FalseEasting  # make e relative to central meridian
-    if h == _S_:
-        n += _FalseNorthing  # make n relative to equator
-    return e, n
-
-
-def _toBand(lat, *unused, **strict_Error):  # see ups._toBand
-    '''(INTERNAL) Get the I{latitudinal} Band (row) letter.
-    '''
-    if _UTM_LAT_MIN <= lat < _UTM_LAT_MAX:  # [-80, 84) like Veness
-        return _Bands[int(lat - _UTM_LAT_MIN) >> 3]
-    elif _xkwds_get(strict_Error, strict=True):
-        r = _range_(_UTM_LAT_MIN, _UTM_LAT_MAX, ropen=True)
-        t = _SPACE_(_outside_, _UTM_, _range_, r)
-        E = _xkwds_get(strict_Error, Error=RangeError)
-        raise E(lat=degDMS(lat), txt=t)
-    else:
-        return NN  # None
-
-
-def _to3zBlat(zone, band, Error=UTMError):  # in .mgrs
-    '''(INTERNAL) Check and return zone, Band and band latitude.
-
-       @arg zone: Zone number or string.
-       @arg band: Band letter.
-       @arg Error: Exception to raise (L{UTMError}).
-
-       @return: 3-Tuple (zone, Band, latitude).
-    '''
-    z, B, _ = _to3zBhp(zone, band, Error=Error)
-    if not (_UTM_ZONE_MIN <= z <= _UTM_ZONE_MAX or
-           (_UPS_ZONE == z and Error is MGRSError)):
-        raise Error(zone=zone)
-
-    b = None
-    if B:
-        if z == _UPS_ZONE:  # polar
-            try:
-                b = Lat(_UPS_LATS[B], name=_bandLat_)
-            except KeyError:
-                raise Error(band=band or B, zone=z)
-        else:  # UTM
-            b = _Bands.find(B)
-            if b < 0:
-                raise Error(band=band or B, zone=z)
-            b = Int((b << 3) - 80, name=_bandLat_)
-        B = Band(B)
-    elif Error is not UTMError:
-        raise Error(band=band, txt=MISSING)
-
-    return Zone(z), B, b
-
-
-def _to4zBll(lat, lon, cmoff=True, strict=True, Error=RangeError):
-    '''(INTERNAL) Return zone, Band and lat- and (central) longitude in degrees.
-
-       @arg lat: Latitude (C{degrees}).
-       @arg lon: Longitude (C{degrees}).
-       @kwarg cmoff: Offset B{C{lon}} from zone's central meridian.
-       @kwarg strict: Restrict B{C{lat}} to UTM ranges (C{bool}).
-       @kwarg Error: Error for out of UTM range B{C{lat}}s.
-
-       @return: 4-Tuple (zone, Band, lat, lon).
-    '''
-    z, lat, lon = _to3zll(lat, lon)  # in .utmupsBase
-
-    x = lon - _cmlon(z)  # z before Norway/Svalbard
-    if fabs(x) > _UTM_ZONE_OFF_MAX:
-        t = _SPACE_(_outside_, _UTM_, _zone_, str(z), _by_, degDMS(x, prec=6))
-        raise Error(lon=degDMS(lon), txt=t)
-
-    B = _toBand(lat, strict=strict, Error=Error)
-    if B == _X_:  # and 0 <= lon < 42: z = int(lon + 183) // 6 + 1
-        x = _SvalbardXzone.get(z, None)
-        if x:  # Svalbard/Spitsbergen archipelago
-            z += 1 if lon >= x else -1
-    elif B == _V_ and z == 31 and lon >= 3:
-        z += 1  # SouthWestern Norway
-
-    if cmoff:  # lon off central meridian
-        lon -= _cmlon(z)  # z after Norway/Svalbard
-    return Zone(z), (Band(B) if B else None), Lat(lat), Lon(lon)
-
-
-def _to7zBlldfn(latlon, lon, datum, falsed, name, zone, strict, Error, **cmoff):
-    '''(INTERNAL) Determine 7-tuple (zone, band, lat, lon, datum,
-        falsed, name) for methods L{toEtm8} and L{toUtm8}.
-    '''
-    f = falsed and _xkwds_get(cmoff, cmoff=True)  # DEPRECATED
-    lat, lon, d, name = _to4lldn(latlon, lon, datum, name)
-    z, B, lat, lon = _to4zBll(lat, lon, cmoff=f, strict=strict)
-    if zone:  # re-zone for ETM/UTM
-        r, _, _ = _to3zBhp(zone, B)
-        if r != z:
-            if not _UTM_ZONE_MIN <= r <= _UTM_ZONE_MAX:
-                raise Error(zone=zone)
-            if f:  # re-offset from central meridian
-                lon += _cmlon(z) - _cmlon(r)
-            z = r
-    return z, B, lat, lon, d, f, name
-
-
 class Utm(UtmUpsBase):
     '''Universal Transverse Mercator (UTM) coordinate.
     '''
@@ -260,7 +145,7 @@ class Utm(UtmUpsBase):
 
     def __init__(self, zone=31, hemisphere=_N_, easting=166022,  # PYCHOK expected
                                 northing=0, band=NN, datum=_WGS84, falsed=True,
-                                gamma=None, scale=None, name=NN, **convergence):
+                                gamma=None, scale=None, **name_convergence):
         '''New L{Utm} UTM coordinate.
 
            @kwarg zone: Longitudinal UTM zone (C{int}, 1..60) or zone with/-out
@@ -275,10 +160,10 @@ class Utm(UtmUpsBase):
            @kwarg falsed: If C{True}, both B{C{easting}} and B{C{northing}} are
                           falsed (C{bool}).
            @kwarg gamma: Optional meridian convergence, bearing off grid North,
-                         clockwise from true North (C{degrees}) or C{None}.
-           @kwarg scale: Optional grid scale factor (C{scalar}) or C{None}.
-           @kwarg name: Optional name (C{str}).
-           @kwarg convergence: DEPRECATED, use keyword argument C{B{gamma}=None}.
+                         clockwise from true North to save (C{degrees}) or C{None}.
+           @kwarg scale: Optional grid scale factor to save (C{scalar}) or C{None}.
+           @kwarg name_convergence: Optional C{B{name}=NN} (C{str}) and DEPRECATED
+                       keyword argument C{B{convergence}=None}, use B{C{gamma}}.
 
            @raise TypeError: Invalid or near-spherical B{C{datum}}.
 
@@ -286,14 +171,17 @@ class Utm(UtmUpsBase):
                             B{C{northing}}, B{C{band}}, B{C{convergence}} or
                             B{C{scale}}.
         '''
-        if name:
-            self.name = name
+        if name_convergence:
+            gamma, name = _xkwds_pop2(name_convergence, convergence=gamma)
+            if name:
+                self.name = name
 
         self._zone, B, _ = _to3zBlat(zone, band)
 
         h = str(hemisphere)[:1].upper()
         if h not in _NS_:
             raise self._Error(hemisphere=hemisphere)
+        self._hemisphere = h
 
         e, n = easting, northing  # Easting(easting), ...
 #       if not falsed:
@@ -307,9 +195,8 @@ class Utm(UtmUpsBase):
 #       if 0 > n or n > _FalseNorthing:
 #           raise RangeError(northing=northing)
 
-        self._hemisphere = h
         UtmUpsBase.__init__(self, e, n, band=B, datum=datum, falsed=falsed,
-                                        gamma=gamma, scale=scale, **convergence)
+                                                gamma=gamma, scale=scale)
 
     def __eq__(self, other):
         return isinstance(other, Utm) and other.zone       == self.zone \
@@ -325,7 +212,7 @@ class Utm(UtmUpsBase):
     def __str__(self):
         return self.toStr()
 
-    def _xcopy2(self, Xtm, name=NN):
+    def _xcopy2(self, Xtm, **name):
         '''(INTERNAL) Make copy as an B{C{Xtm}} instance.
 
            @arg Xtm: Class to return the copy (C{Xtm=Etm}, C{Xtm=Utm} or
@@ -333,7 +220,7 @@ class Utm(UtmUpsBase):
         '''
         return Xtm(self.zone, self.hemisphere, self.easting, self.northing,
                    band=self.band, datum=self.datum, falsed=self.falsed,
-                   gamma=self.gamma, scale=self.scale, name=name or self.name)
+                   gamma=self.gamma, scale=self.scale, name=self._name__(name))
 
     @property_doc_(''' the I{latitudinal} band.''')
     def band(self):
@@ -371,13 +258,11 @@ class Utm(UtmUpsBase):
                 n = _FalseNorthing
         return EasNor2Tuple(e, n)
 
-    def parse(self, strUTM, name=NN):
+    def parse(self, strUTM, **name):
         '''Parse a string to a similar L{Utm} instance.
 
-           @arg strUTM: The UTM coordinate (C{str}),
-                        see function L{parseUTM5}.
-           @kwarg name: Optional instance name (C{str}),
-                        overriding this name.
+           @arg strUTM: The UTM coordinate (C{str}), see function L{parseUTM5}.
+           @kwarg name: Optional instance name (C{str}), overriding this name.
 
            @return: The similar instance (L{Utm}).
 
@@ -386,7 +271,7 @@ class Utm(UtmUpsBase):
            @see: Functions L{pygeodesy.parseUPS5} and L{pygeodesy.parseUTMUPS5}.
         '''
         return parseUTM5(strUTM, datum=self.datum, Utm=self.classof,
-                                 name=name or self.name)
+                                 name=self._name__(name))
 
     @deprecated_method
     def parseUTM(self, strUTM):  # PYCHOK no cover
@@ -479,11 +364,12 @@ class Utm(UtmUpsBase):
         # gamma and scale: Karney 2011 Eq 26, 27 and 28
         p = neg(K.ps(-1))
         q =     K.qs(0)
-        s = hypot(p, q) * E.a / A0
-        ll._gamma = degrees(atan1(tan(y) * tanh(x)) + atan2(q, p))
-        ll._scale = (E.e2s(sin(a)) * hypot1(T) * H / s) if s else s  # INF?
+        g = degrees(atan1(tan(y) * tanh(x)) + atan2(q, p))
+        k = hypot(p, q) * E.a / A0
+        if k:
+            k = E.e2s(sin(a)) * hypot1(T) * H / k  # INF?
         ll._iteration = i
-        self._latlon5args(ll, _toBand, unfalse, eps)
+        self._latlon5args(ll, g, k, _toBand, unfalse, eps)
 
     def toRepr(self, prec=0, fmt=Fmt.SQUARE, sep=_COMMASPACE_, B=False, cs=False, **unused):  # PYCHOK expected
         '''Return a string representation of this UTM coordinate.
@@ -536,12 +422,13 @@ class Utm(UtmUpsBase):
                         (C{str}, 'N[orth]'|'S[outh]').
            @kwarg eps: Optional convergence limit, L{EPS} or above
                        (C{float}), see method L{Utm.toLatLon}.
-           @kwarg falsed: False both easting and northing (C{bool}).
+           @kwarg falsed: If C{True}, false both easting and northing
+                          (C{bool}).
 
            @return: The UPS coordinate (L{Ups}).
         '''
         u = self._ups
-        if u is None or u.pole != (pole or u.pole) or falsed != bool(u.falsed):
+        if u is None or u.pole != (pole or u.pole) or bool(falsed) != u.falsed:
             ll  =  self.toLatLon(LatLon=_LLEB, eps=eps, unfalse=True)
             ups = _MODS.ups
             self._ups = u = ups.toUps8(ll, Ups=ups.Ups, falsed=falsed,
@@ -554,7 +441,8 @@ class Utm(UtmUpsBase):
            @arg zone: New UTM zone (C{int}).
            @kwarg eps: Optional convergence limit, L{EPS} or above
                        (C{float}), see method L{Utm.toLatLon}.
-           @kwarg falsed: False both easting and northing (C{bool}).
+           @kwarg falsed: If C{True}, fFalse both easting and northing
+                          (C{bool}).
 
            @return: The UTM coordinate (L{Utm}).
         '''
@@ -562,7 +450,7 @@ class Utm(UtmUpsBase):
             return self.copy()
         elif zone:
             u = self._utm
-            if u is None or u.zone != zone or falsed != u.falsed:
+            if u is None or u.zone != zone or bool(falsed) != u.falsed:
                 ll = self.toLatLon(LatLon=_LLEB, eps=eps, unfalse=True)
                 self._utm = u = toUtm8(ll, Utm=self.classof, falsed=falsed,
                                            name=self.name, zone=zone)
@@ -576,7 +464,25 @@ class Utm(UtmUpsBase):
         return self._zone
 
 
-def _parseUTM5(strUTM, datum, Xtm, falsed, Error=UTMError, name=NN):  # imported by .etm
+def _cmlon(zone):
+    '''(INTERNAL) Central meridian longitude (C{degrees180}).
+    '''
+    return (zone * 6) - 183
+
+
+def _false2(e, n, h):
+    '''(INTERNAL) False easting and northing.
+    '''
+    # Karney, "Test data for the transverse Mercator projection (2009)"
+    # <https://GeographicLib.SourceForge.io/C++/doc/transversemercator.html>
+    # and <https://Zenodo.org/record/32470#.W4LEJS2ZON8>
+    e += _FalseEasting  # make e relative to central meridian
+    if h == _S_:
+        n += _FalseNorthing  # make n relative to equator
+    return e, n
+
+
+def _parseUTM5(strUTM, datum, Xtm, falsed, Error=UTMError, **name):  # imported by .etm
     '''(INTERNAL) Parse a string representing a UTM coordinate,
        consisting of C{"zone[band] hemisphere easting northing"},
        see L{pygeodesy.parseETM5} and L{parseUTM5}.
@@ -585,16 +491,11 @@ def _parseUTM5(strUTM, datum, Xtm, falsed, Error=UTMError, name=NN):  # imported
     if _UTM_ZONE_MIN > z or z > _UTM_ZONE_MAX or (B and B not in _Bands):
         raise Error(strUTM=strUTM, zone=z, band=B)
 
-    if Xtm is None:
-        r = UtmUps5Tuple(z, h, e, n, B, Error=Error, name=name)
-    else:
-        r = Xtm(z, h, e, n, band=B, datum=datum, falsed=falsed)
-        if name:
-            r = _xnamed(r, name, force=True)
-    return r
+    return UtmUps5Tuple(z, h, e, n, B, Error=Error, **name) if Xtm is None else \
+                    Xtm(z, h, e, n, band=B, datum=datum, falsed=bool(falsed), **name)
 
 
-def parseUTM5(strUTM, datum=_WGS84, Utm=Utm, falsed=True, name=NN):
+def parseUTM5(strUTM, datum=_WGS84, Utm=Utm, falsed=True, **name):
     '''Parse a string representing a UTM coordinate, consisting
        of C{"zone[band] hemisphere easting northing"}.
 
@@ -603,8 +504,9 @@ def parseUTM5(strUTM, datum=_WGS84, Utm=Utm, falsed=True, name=NN):
                      L{Ellipsoid2} or L{a_f2Tuple}).
        @kwarg Utm: Optional class to return the UTM coordinate
                    (L{Utm}) or C{None}.
-       @kwarg falsed: Both easting and northing are falsed (C{bool}).
-       @kwarg name: Optional B{C{Utm}} name (C{str}).
+       @kwarg falsed: Use C{B{falsed}=True} if both easting and
+                      northing are falsed (C{bool}).
+       @kwarg name: Optional B{C{Utm}} C{B{name}=NN} (C{str}).
 
        @return: The UTM coordinate (B{C{Utm}}) or if B{C{Utm}}
                 is C{None}, a L{UtmUps5Tuple}C{(zone, hemipole,
@@ -615,28 +517,29 @@ def parseUTM5(strUTM, datum=_WGS84, Utm=Utm, falsed=True, name=NN):
 
        @raise TypeError: Invalid B{C{datum}}.
     '''
-    return _parseUTM5(strUTM, datum, Utm, falsed, name=name)
+    return _parseUTM5(strUTM, datum, Utm, falsed, **name)
 
 
 def toUtm8(latlon, lon=None, datum=None, Utm=Utm, falsed=True,
-                                         name=NN, strict=True,
-                                         zone=None, **cmoff):
+                             strict=True, zone=None, **name_cmoff):
     '''Convert a lat-/longitude point to a UTM coordinate.
 
        @arg latlon: Latitude (C{degrees}) or an (ellipsoidal)
                     geodetic C{LatLon} point.
-       @kwarg lon: Optional longitude (C{degrees}) or C{None}.
+       @kwarg lon: Optional longitude (C{degrees}), required
+                   if B{C{latlon}} is in C{degrees}.
        @kwarg datum: Optional datum for this UTM coordinate,
                      overriding B{C{latlon}}'s datum (L{Datum},
                      L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}).
        @kwarg Utm: Optional class to return the UTM coordinate
                    (L{Utm}) or C{None}.
        @kwarg falsed: False both easting and northing (C{bool}).
-       @kwarg name: Optional B{C{Utm}} name (C{str}).
        @kwarg strict: Restrict B{C{lat}} to UTM ranges (C{bool}).
        @kwarg zone: Optional UTM zone to enforce (C{int} or C{str}).
-       @kwarg cmoff: DEPRECATED, use B{C{falsed}}.  Offset longitude
-                     from the zone's central meridian (C{bool}).
+       @kwarg name_cmoff: Optional B{C{Utm}} C{B{name}=NN} (C{str}) and
+                   DEPRECATED C{B{cmoff}=True} to offset the longitude
+                   from the zone's central meridian (C{bool}), use
+                   C{B{falsed}} instead.
 
        @return: The UTM coordinate (B{C{Utm}}) or if B{C{Utm}} is
                 C{None} or not B{C{falsed}}, a L{UtmUps8Tuple}C{(zone,
@@ -651,17 +554,17 @@ def toUtm8(latlon, lon=None, datum=None, Utm=Utm, falsed=True,
 
        @raise UTMError: Invalid B{C{zone}}.
 
-       @raise ValueError: If B{C{lon}} value is missing or if
-                          B{C{latlon}} is invalid.
+       @raise ValueError: If B{C{lon}} value is missing or B{C{latlon}}
+                          is invalid.
 
        @note: Implements Karney’s method, using 8-th order Krüger series,
               giving results accurate to 5 nm (or better) for distances
               up to 3,900 Km from the central meridian.
     '''
-    z, B, lat, lon, d, f, name = _to7zBlldfn(latlon, lon, datum,
-                                             falsed, name, zone,
-                                             strict, UTMError, **cmoff)
-    d = _ellipsoidal_datum(d, name=name)
+    z, B, lat, lon, d, f, n = _to7zBlldfn(latlon, lon, datum,
+                                          falsed, zone, strict,
+                                          UTMError, **name_cmoff)
+    d = _ellipsoidal_datum(d, name=n)
     E = d.ellipsoid
 
     a, b = radians(lat), radians(lon)
@@ -681,8 +584,8 @@ def toUtm8(latlon, lon=None, datum=None, Utm=Utm, falsed=True,
     A0 = E.A * getattr(Utm, _under(_scale0_), _K0_UTM)  # Utm is class or None
 
     K = _Kseries(E.AlphaKs, x, y)  # Krüger series
-    y = K.ys(y) * A0  # ξ
-    x = K.xs(x) * A0  # η
+    y =  K.ys(y) * A0  # ξ
+    x =  K.xs(x) * A0  # η
 
     # convergence: Karney 2011 Eq 23, 24
     p_ = K.ps(1)
@@ -692,43 +595,136 @@ def toUtm8(latlon, lon=None, datum=None, Utm=Utm, falsed=True,
     k  = E.e2s(sin(a)) * T12 / H * (A0 / E.a * hypot(p_, q_))
 
     return _toXtm8(Utm, z, lat, x, y,
-                        B, d, g, k, f, name, latlon, EPS)
+                        B, d, g, k, f, n, latlon, EPS)
+
+
+def _toBand(lat, *unused, **strict_Error):  # see ups._toBand
+    '''(INTERNAL) Get the I{latitudinal} Band (row) letter.
+    '''
+    if _UTM_LAT_MIN <= lat < _UTM_LAT_MAX:  # [-80, 84) like Veness
+        return _Bands[int(lat - _UTM_LAT_MIN) >> 3]
+    elif _xkwds_get(strict_Error, strict=True):
+        r = _range_(_UTM_LAT_MIN, _UTM_LAT_MAX, ropen=True)
+        t = _SPACE_(_outside_, _UTM_, _range_, r)
+        E = _xkwds_get(strict_Error, Error=RangeError)
+        raise E(lat=degDMS(lat), txt=t)
+    else:
+        return NN  # None
 
 
 def _toXtm8(Xtm, z, lat, x, y, B, d, g, k, f,  # PYCHOK 13+ args
-                 name, latlon, eps, Error=UTMError):
+                 n, latlon, eps_other, Error=UTMError):
     '''(INTERNAL) Helper for methods L{toEtm8} and L{toUtm8}.
     '''
     h = _hemi(lat)
     if f:
         x, y = _false2(x, y, h)
     if Xtm is None:  # DEPRECATED
-        r = UtmUps8Tuple(z, h, x, y, B, d, g, k, Error=Error, name=name)
+        r = UtmUps8Tuple(z, h, x, y, B, d, g, k, Error=Error, name=n)
     else:
-        r = _xnamed(Xtm(z, h, x, y, band=B, datum=d, falsed=f,
-                                            gamma=g, scale=k), name)
+        r = Xtm(z, h, x, y, band=B, datum=d, falsed=f,
+                                    gamma=g, scale=k, name=n)
         if isinstance(latlon, _LLEB) and d is latlon.datum:  # see ups.toUtm8
-            r._latlon5args(latlon, _toBand, f, eps)  # XXX weakref(latlon)?
-            latlon._gamma = g
-            latlon._scale = k
+            r._latlon5args(latlon, g, k, _toBand, f, eps_other)  # XXX weakref(latlon)?
         elif not r._band:
             r._band = _toBand(lat)
     return r
 
 
-def utmZoneBand5(lat, lon, cmoff=False, name=NN):
+def _to3zBlat(zone, band, Error=UTMError):  # in .mgrs
+    '''(INTERNAL) Check and return zone, Band and band latitude.
+
+       @arg zone: Zone number or string.
+       @arg band: Band letter.
+       @arg Error: Exception to raise (L{UTMError}).
+
+       @return: 3-Tuple (zone, Band, latitude).
+    '''
+    z, B, _ = _to3zBhp(zone, band, Error=Error)
+    if not (_UTM_ZONE_MIN <= z <= _UTM_ZONE_MAX or
+           (_UPS_ZONE == z and Error is MGRSError)):
+        raise Error(zone=zone)
+
+    b = None
+    if B:
+        if z == _UPS_ZONE:  # polar
+            try:
+                b = Lat(_UPS_LATS[B], name=_bandLat_)
+            except KeyError:
+                raise Error(band=band or B, zone=z)
+        else:  # UTM
+            b = _Bands.find(B)
+            if b < 0:
+                raise Error(band=band or B, zone=z)
+            b = Int((b << 3) - 80, name=_bandLat_)
+        B = Band(B)
+    elif Error is not UTMError:
+        raise Error(band=band, txt=MISSING)
+
+    return Zone(z), B, b
+
+
+def _to4zBll(lat, lon, cmoff=True, strict=True, Error=RangeError):
+    '''(INTERNAL) Return zone, Band and lat- and (central) longitude in degrees.
+
+       @arg lat: Latitude (C{degrees}).
+       @arg lon: Longitude (C{degrees}).
+       @kwarg cmoff: If C{True}, offset B{C{lon}} from the zone's central meridian.
+       @kwarg strict: Restrict B{C{lat}} to the UTM ranges (C{bool}).
+       @kwarg Error: Error for out of UTM range B{C{lat}}s.
+
+       @return: 4-Tuple (zone, Band, lat, lon).
+    '''
+    z, lat, lon = _to3zll(lat, lon)  # in .utmupsBase
+
+    x = lon - _cmlon(z)  # z before Norway/Svalbard
+    if fabs(x) > _UTM_ZONE_OFF_MAX:
+        t = _SPACE_(_outside_, _UTM_, _zone_, str(z), _by_, degDMS(x, prec=6))
+        raise Error(lon=degDMS(lon), txt=t)
+
+    B = _toBand(lat, strict=strict, Error=Error)
+    if B == _X_:  # and 0 <= lon < 42: z = int(lon + 183) // 6 + 1
+        x = _SvalbardXzone.get(z, None)
+        if x:  # Svalbard/Spitsbergen archipelago
+            z += 1 if lon >= x else -1
+    elif B == _V_ and z == 31 and lon >= 3:
+        z += 1  # SouthWestern Norway
+
+    if cmoff:  # lon off central meridian
+        lon -= _cmlon(z)  # z I{after} Norway/Svalbard
+    return Zone(z), (Band(B) if B else None), Lat(lat), Lon(lon)
+
+
+def _to7zBlldfn(latlon, lon, datum, falsed, zone, strict, Error, **name_cmoff):
+    '''(INTERNAL) Determine 7-tuple (zone, band, lat, lon, datum,
+        falsed, name) for methods L{toEtm8} and L{toUtm8}.
+    '''
+    f, name = _xkwds_pop2(name_cmoff, cmoff=falsed)  # DEPRECATED
+    lat, lon, d, n = _to4lldn(latlon, lon, datum, name)
+    z, B, lat, lon = _to4zBll(lat, lon, cmoff=f, strict=strict)
+    if zone:  # re-zone for ETM/UTM
+        r, _, _ = _to3zBhp(zone, B)
+        if r != z:
+            if not _UTM_ZONE_MIN <= r <= _UTM_ZONE_MAX:
+                raise Error(zone=zone)
+            if f:  # re-offset from central meridian
+                lon += _cmlon(z) - _cmlon(r)
+            z = r
+    return z, B, lat, lon, d, f, n
+
+
+def utmZoneBand5(lat, lon, cmoff=False, **name):
     '''Return the UTM zone number, Band letter, hemisphere and
        (clipped) lat- and longitude for a given location.
 
        @arg lat: Latitude in degrees (C{scalar} or C{str}).
        @arg lon: Longitude in degrees (C{scalar} or C{str}).
-       @kwarg cmoff: Offset longitude from the zone's central
+       @kwarg cmoff: If C{True}, offset longitude from the zone's central
                      meridian (C{bool}).
-       @kwarg name: Optional name (C{str}).
+       @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-       @return: A L{UtmUpsLatLon5Tuple}C{(zone, band, hemipole,
-                lat, lon)} where C{hemipole} is the C{'N'|'S'}
-                UTM hemisphere.
+       @return: A L{UtmUpsLatLon5Tuple}C{(zone, band, hemipole, lat, lon)}
+                where C{hemipole} is the C{'N'|'S'} UTM hemisphere.
 
        @raise RangeError: If B{C{lat}} outside the valid UTM bands or if
                           B{C{lat}} or B{C{lon}} outside the valid range
@@ -738,7 +734,7 @@ def utmZoneBand5(lat, lon, cmoff=False, name=NN):
     '''
     lat, lon = parseDMS2(lat, lon)
     z, B, lat, lon = _to4zBll(lat, lon, cmoff=cmoff)
-    return UtmUpsLatLon5Tuple(z, B, _hemi(lat), lat, lon, name=name)
+    return UtmUpsLatLon5Tuple(z, B, _hemi(lat), lat, lon, **name)
 
 # **) MIT License
 #