pygeodesy 24.5.24__py2.py3-none-any.whl → 24.6.9__py2.py3-none-any.whl

pygeodesy/lazily.py

@@ -29,39 +29,33 @@ and line number.
 
 from pygeodesy import internals as _internals, interns as _interns, \
                      _isfrozen  # DON'T _lazy_import2
-# from pygeodesy.errors import _error_init  # _ALL_MODS
+# from pygeodesy.errors import _error_init, _xkwds_item2  # _ALL_MODS
 from pygeodesy.internals import _caller3, _dunder_nameof, _dunder_ismain, \
                                 _headof, _osversion2, printf, _Pythonarchine, \
-                                _tailof
-from pygeodesy.interns import NN, _areaOf_, _attribute_, _by_, _COLONSPACE_, \
-                             _COMMASPACE_, _doesn_t_exist_, _DOT_, _enabled_, \
-                             _EQUALSPACED_, _from_, _HASH_, _immutable_, \
-                             _isclockwise_, _ispolar_, _line_, _module_, \
-                             _no_, _NorthPole_, _not_, _or_, _pygeodesy_, \
-                             _pygeodesy_abspath_, _SouthPole_, \
-                             _SPACE_, _sub_packages, _sys, _UNDER_, _version_, \
+                                _tailof  # _Property_RO
+from pygeodesy.interns import NN, _attribute_, _by_, _COLONSPACE_, _COMMASPACE_, \
+                             _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \
+                             _HASH_, _immutable_, _line_, _module_, _no_, _not_, \
+                             _or_, _pygeodesy_abspath_, _pygeodesy_, _SPACE_, \
+                             _SUB_PACKAGES, _UNDER_, _version_,  _sys, \
                              _intern  # function
 # from pygeodesy.streprs import unstr  # _ALL_MODS
 
-from os import getenv as _getenv
 try:
     from importlib import import_module
 except ImportError as x:  # Python 2.6-
-    _str_x = str(x)
-
-    def import_module(name, *package):
-        t = _ALL_MODS.streprs.unstr(import_module, name, *package)
-        raise LazyImportError(t, txt=_str_x)
+    raise ImportError(_COLONSPACE_(_Pythonarchine(sep=_SPACE_), x))
+from os import getenv as _getenv
+# import sys as _sys  # from .interns
 
 __as__                  = ' as '
 _dunder_all_            = '__all__'  # in .__main__
-_dunder_package_        = '__package__'
+_enabled_               = 'enabled'
 _FOR_DOCS               = _getenv('PYGEODESY_FOR_DOCS', NN)  # for epydoc ...
-_from_DOT__             = _SPACE_(NN, _from_, _DOT_)
 _i0                     = ()  # PYCHOK empty tuple
 _init__all__            = _FOR_DOCS or _getenv('PYGEODESY_INIT__ALL__', _dunder_all_) == _dunder_all_  # PYCHOK exported
 _lazily_                = 'lazily'
-_lazily_imported__      = _SPACE_(_HASH_, _lazily_, 'imported', NN)
+_lazily_imported_       = _SPACE_(_HASH_, _lazily_, 'imported')
 _PYGEODESY_GEOCONVERT_  = 'PYGEODESY_GEOCONVERT'  # PYCHOK .mgrs, test.bases
 _PYGEODESY_GEODSOLVE_   = 'PYGEODESY_GEODSOLVE'   # PYCHOK .geodsolve, test.bases
 _PYGEODESY_LAZY_IMPORT_ = 'PYGEODESY_LAZY_IMPORT'
@@ -73,7 +67,7 @@ _unlazy = _unLazy0      = _isfrozen or _sys_version_info2 < (3, 7)  # PYCHOK mod
 _WARNINGS_X_DEV         = _getenv('PYGEODESY_WARNINGS', NN) and (
                           _PYTHON_X_DEV or bool(_sys.warnoptions))  # PYCHOK .props
 # @module_property[_RO?] <https://GitHub.com/jtushman/proxy_tools/>
-isLazy                  = None  # see @var isLazy in .__init__
+isLazy                  =  None  # see @var isLazy in .__init__
 
 
 class LazyAttributeError(AttributeError):
@@ -168,7 +162,7 @@ class _NamedEnum_RO(dict):
             for a in t:
                 a, _, as_ = a.partition(__as__)
                 if as_:  # import attr as attr_
-                    _a(as_, _DOT_(m, a, NN), *_sub_packages)
+                    _a(as_, _DOT_(m, a, NN), *_SUB_PACKAGES)
                 else:
                     _a(a, m)
         return _D
@@ -185,7 +179,7 @@ def _ALL_ATTRS(*attrs):
     '''
     t = ()
     for attr in attrs:
-        t += tuple(map(_attrof, attr))
+        t += tuple(map(_getattrof, attr))
     return t
 
 
@@ -269,7 +263,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'antipode', 'antipode_', 'bearing', 'bearing_',
                                    'compassAngle', 'cosineForsytheAndoyerLambert', 'cosineForsytheAndoyerLambert_',
                                    'cosineAndoyerLambert', 'cosineAndoyerLambert_', 'cosineLaw', 'cosineLaw_',
-                                   'equirectangular', 'equirectangular_', 'euclidean', 'euclidean_',
+                                   'equirectangular', 'equirectangular4', 'euclidean', 'euclidean_',
                                    'excessAbc_', 'excessCagnoli_', 'excessGirard_', 'excessLHuilier_',
                                    'excessKarney', 'excessKarney_', 'excessQuad', 'excessQuad_',
                                    'flatLocal', 'flatLocal_', 'flatPolar', 'flatPolar_',
@@ -290,7 +284,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'fsum', 'fsum_', 'fsumf_', 'fsum1', 'fsum1_', 'fsum1f_'),
                            gars=_i('Garef', 'GARSError'),
                       geodesicw=_i('Geodesic', 'GeodesicLine', 'Geodesic_WGS84'),
-                      geodesicx=_i('gx', 'gxarea', 'gxbases', 'gxline',  # modules, see _sub_packages
+                      geodesicx=_i('gx', 'gxarea', 'gxbases', 'gxline',  # modules
                                    'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'),
                       geodsolve=_i('GeodesicSolve', 'GeodesicLineSolve', 'GeodSolve12Tuple'),
                         geohash=_i('Geohash', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple'),
@@ -340,11 +334,11 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'Reverse4Tuple', 'Triangle7Tuple', 'Triangle8Tuple', 'Trilaterate5Tuple',
                                    'UtmUps2Tuple', 'UtmUps5Tuple', 'UtmUps8Tuple', 'UtmUpsLatLon5Tuple',
                                    'Vector2Tuple', 'Vector3Tuple', 'Vector4Tuple'),
-                    nvectorBase=_i(_NorthPole_, _SouthPole_),
+                    nvectorBase=_i('NorthPole', 'SouthPole'),
                            osgr=_i('Osgr', 'OSGRError', 'parseOSGR', 'toOsgr'),
                          points=_i('LatLon_', 'LatLon2psxy', 'Numpy2LatLon', 'Shape2Tuple', 'Tuple2LatLon',
-                                   _areaOf_, 'boundsOf', 'centroidOf', 'fractional',
-                                   _isclockwise_, 'isconvex', 'isconvex_', 'isenclosedBy', _ispolar_,
+                                   'areaOf', 'boundsOf', 'centroidOf', 'fractional',
+                                   'isclockwise', 'isconvex', 'isconvex_', 'isenclosedBy', 'ispolar',
                                    'luneOf', 'nearestOn5', 'perimeterOf', 'quadOf'),
                           props=_i('Property', 'Property_RO', 'property_RO', 'property_doc_',
                                    'deprecated_class', 'deprecated_function', 'deprecated_method',
@@ -421,7 +415,7 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                                          'R_M', 'R_MA', 'R_MB', 'R_KM', 'R_NM', 'R_SM', 'R_FM', 'R_VM'),
                  deprecated_functions=_i('anStr', 'areaof', 'atand', 'bounds',  # most of the DEPRECATED functions, except ...
                                          'clipCS3', 'clipDMS', 'clipStr', 'collins', 'copysign',  # ...  ellipsoidal, spherical flavors
-                                         'decodeEPSG2', 'encodeEPSG', 'enStr2', 'equirectangular3',
+                                         'decodeEPSG2', 'encodeEPSG', 'enStr2', 'equirectangular_', 'equirectangular3',
                                          'excessAbc', 'excessGirard', 'excessLHuilier',
                                          'false2f', 'falsed2f', 'float0', 'fStr', 'fStrzs', 'hypot3',
                                          'inStr', 'isenclosedby', 'istuplist',
@@ -432,7 +426,7 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                    deprecated_nvector=_i('LatLonNvectorBase', 'Nvector', 'sumOf', 'NorthPole', 'SouthPole'),)
 
 
-class _ALL_MODS(_internals._ALL_MODS_Base):
+class _ALL_MODS(_internals._MODS_Base):
     '''(INTERNAL) Memoized import of any L{pygeodesy} module.
     '''
     def __getattr__(self, name):
@@ -474,7 +468,7 @@ class _ALL_MODS(_internals._ALL_MODS_Base):
         return v
 
     def getmodule(self, name, parent=_pygeodesy_):
-        '''Get a C{pygeodesy} module.
+        '''Get a C{pygeodesy} module or the C{__main__}.
 
            @arg name: Un/qualified module name (C{str}).
 
@@ -482,12 +476,36 @@ class _ALL_MODS(_internals._ALL_MODS_Base):
 
            @raise ImportError: Importing module B{C{name}} failed.
         '''
-        if _headof(name) != parent:
+        if _headof(name) != parent and not _dunder_ismain(name):
             name = _DOT_(parent, name)
         try:
             return _sys.modules[name]
         except KeyError:
-            return import_module(name, parent)
+            return _getmodule(name, parent)
+
+    def into(self, **mod_dunder_name_):
+        '''Lazily import module C{mod} into module C{_dunder_name_}
+           and set C{_dunder_name_._mod} to module C{mod}, I{once}.
+        '''
+        class _Into(object):
+
+            def __getattr__(unused, name):
+                mod, dun = self.errors._xkwds_item2(mod_dunder_name_)
+                _mod = _UNDER_(NN, mod)
+                d =  self.getmodule(dun)  # '__main__' OK
+                i = _getattribute(d, _mod, dun)
+                assert isinstance(i, _Into)
+                m =  self.getmodule(mod)
+                setattr(d, _mod, m)  # overwrite C{d._mod}
+                return getattr(m, name)
+
+        return _Into()
+
+#   @_Property_RO
+#   def _isBoolean(self):
+#       '''(INTERNAL) Get function C(.booleans.isBoolean}, I{once}.
+#       '''
+#       return self.booleans.isBoolean
 
     def items(self):  # no module named 'items'
         '''Yield the modules imported so far.
@@ -500,7 +518,7 @@ class _ALL_MODS(_internals._ALL_MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.05.15'
+__version__ = '24.06.05'
 
 
 def _ALL_OTHER(*objs):
@@ -565,11 +583,34 @@ def _all_missing2(_all_):
             (_DOT_(_pygeodesy_, _dunder_all_), _diff(_alzy.keys(), _all_)))
 
 
-def _attrof(attr_as):  # .testDeprecated
+def _getattribute(m, name, mod=_pygeodesy_):
+    '''(INTERNAL) Get attr C{m.name}.
+    '''
+    try:
+        return getattr(m, name)
+    except AttributeError:
+        name = _DOT_(mod, name)
+        # <https://GitHub.com/mrJean1/PyGeodesy/issues/76>
+        raise LazyAttributeError(_no_(_attribute_), txt=name)
+
+
+def _getattrof(attr_as):  # .testDeprecated
+    '''(INTERNAL) Get the C{"as name"} or C{"name"} of a lazy entry.
+    '''
     a_, _, as_ = attr_as.partition(__as__)
     return as_ or a_.rstrip(_DOT_)
 
 
+def _getmodule(name, *parent):
+    '''(INTERNAL) Wrapper for C{import_module}.
+    '''
+    try:
+        return import_module(name, parent)
+    except ImportError:
+        # <https://GitHub.com/mrJean1/PyGeodesy/issues/76>
+        raise LazyImportError(_no_(_module_), txt=name)
+
+
 # def _lazy_attributes(_dunder_name_):
 #     '''(INTERNAL) Return a function to C{B{__name__}.__getattr__(attr)}
 #        on lazily imported modules and sub-modules.
@@ -615,17 +656,19 @@ def _lazy_import2(pack):  # MCCABE 14
              U{PEP 562<https://www.Python.org/dev/peps/pep-0562>} and the
              U{new way<https://Snarky.Ca/lazy-importing-in-python-3-7/>}.
     '''
+    _DOT_    = _interns._DOT_
+    _SPACE_  = _interns._SPACE_
+
     if pack != _pygeodesy_ or _unlazy:  # Python 3.7+
         t = _no_(_DOT_(pack, _dunder_nameof(_lazy_import2)))  # PYCHOK no cover
         raise LazyImportError(t, txt=_Pythonarchine(sep=_SPACE_))
 
-    package, parent = _lazy_init2(pack)  # _pygeodesy_
-
-    subpacks   =  set((parent, NN) + tuple(
-                      _DOT_(parent, s) for s in _sub_packages))
-    MISSING    =  object()  # DON'T interns.MISSING!
-    imports    = _all_imports()
-    deprecates = _all_deprecates()
+    package, parent  = _lazy_init2(pack)  # _pygeodesy_
+    sub_packages     =  set((parent, NN) + tuple(
+                           _DOT_(parent, s) for s in _SUB_PACKAGES))
+    imports          = _all_imports()
+    deprecates       = _all_deprecates()
+    _dunder_package_ = '__package__'
 
     def __getattr__(name):  # __getattr__ only for Python 3.7+
         # only called once for each undefined pygeodesy attribute
@@ -638,21 +681,12 @@ def _lazy_import2(pack):  # MCCABE 14
                 mod, _, attr = mod[:-1].rpartition(_DOT_)
             else:  # from mod import name
                 attr = name
-            try:
-                t = _DOT_(pack, mod)
-                v =  import_module(t, parent)
-            except ImportError:
-                # <https://GitHub.com/mrJean1/PyGeodesy/issues/76>
-                raise LazyImportError(_no_(_module_), txt=t)
-            t = getattr(v, _dunder_package_, None)
-            if t not in subpacks:  # invalid module package
+            v = _getmodule(_DOT_(pack, mod), parent)
+            t =  getattr(v, _dunder_package_, None)
+            if t not in sub_packages:  # invalid module package
                 raise LazyImportError(_DOT_(mod, _dunder_package_), t)
-            if attr:  # get the attribute
-                v = getattr(v, attr, MISSING)
-                if v is MISSING:  # PYCHOK no cover
-                    t = _DOT_(mod, attr)
-                    # <https://GitHub.com/mrJean1/PyGeodesy/issues/76>
-                    raise LazyAttributeError(_no_(_attribute_), txt=t)
+            if attr:  # get mod.attr
+                v = _getattribute(v, attr, mod)
 
         elif name in (_dunder_all_,):  # XXX _dunder_dir_, _dunder_members_?
             v = _ALL_INIT + tuple(imports.keys())
@@ -663,9 +697,9 @@ def _lazy_import2(pack):  # MCCABE 14
 
         setattr(package, name, v)  # package.__dict__[name] = val
         if isLazy > 1:
-            t = NN(_lazily_imported__, _DOT_(parent, name))
+            t = _SPACE_(_lazily_imported_, _DOT_(parent, name))
             if mod and _tailof(mod) != name:
-                t = NN(t, _from_DOT__, mod)
+                t = _SPACE_(t, _from_, _DOT_(NN, mod))
             if isLazy > 2:
                 try:  # see C{_caller3}
                     _, f, s = _caller3(2)
@@ -827,6 +861,8 @@ def _lazy_module(name):  # overwritten by _lazy_import2
 
 # del _i, _i0
 
+# _ = _ALL_MODS.errors  # force import pygeodesy.errors
+
 if _dunder_ismain(__name__):  # PYCHOK no cover
 
     from timeit import timeit

pygeodesy/lcc.py

@@ -48,7 +48,7 @@ from pygeodesy.utily import atan1, degrees90, degrees180, sincos2, tanPI_2_2
 from math import atan, fabs, log, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.lcc
-__version__ = '24.05.24'
+__version__ = '24.06.09'
 
 _E0_   = 'E0'
 _N0_   = 'N0'
@@ -454,7 +454,7 @@ class Lcc(_NamedBase):
 #
 #       kwds = _xkwds(e_n_h_conic, e=self.easting, n=self.northing,
 #                                  h=self.height, conic=self.conic,
-#                                  name=name or self.name)
+#                                  name=self._name__(name))
 #       args, kwds = _args_kwds(**kwds)
 #       return self.__class__(*args, **kwds)  # .classof
 

pygeodesy/ltp.py

@@ -13,23 +13,25 @@ and L{ChLVe} and L{Ltp}, L{ChLV}, L{LocalError}, L{Attitude} and L{Frustum}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import _args_kwds_names, issubclassof, map1, map2   # .datums
+from pygeodesy.basics import _args_kwds_names, map1, map2, _xinstanceof, \
+                             _xsubclassof   # .datums
 from pygeodesy.constants import EPS, INT0, _umod_360, _0_0, _0_01, _0_5, _1_0, \
                                _2_0, _60_0, _90_0, _100_0, _180_0, _3600_0, \
                                _N_1_0  # PYCHOK used!
-from pygeodesy.datums import _WGS84,  _xinstanceof
-from pygeodesy.ecef import _EcefBase, EcefKarney, _llhn4, _xyzn4
-from pygeodesy.errors import _NotImplementedError, _TypesError, _ValueError, \
-                             _xattr, _xkwds, _xkwds_get, _xkwds_pop2
+# from pygeodesy.datums import _WGS84  # from .ecef
+from pygeodesy.ecef import _EcefBase, EcefKarney, Ecef9Tuple, _llhn4, \
+                           _xyzn4,  _WGS84
+from pygeodesy.errors import _NotImplementedError, _ValueError, _xattr, \
+                             _xkwds, _xkwds_get, _xkwds_pop2
 from pygeodesy.fmath import fabs, fdot, Fhorner
 from pygeodesy.fsums import _floor, _Fsumf_, fsumf_, fsum1f_
 from pygeodesy.interns import _0_, _COMMASPACE_, _DOT_, _ecef_, _height_, _M_, \
-                              _invalid_, _lat0_, _lon0_, _ltp_, _name_, _too_
+                              _invalid_, _lat0_, _lon0_, _name_, _too_
 # from pygeodesy.lazily import _ALL_LAZY  # from vector3d
 from pygeodesy.ltpTuples import Attitude4Tuple, ChLVEN2Tuple, ChLV9Tuple, \
                                 ChLVYX2Tuple, Footprint5Tuple, Local9Tuple, \
                                 ChLVyx2Tuple, _XyzLocals4, _XyzLocals5, Xyz4Tuple
-from pygeodesy.named import _name__, _NamedBase, notOverloaded
+from pygeodesy.named import _name__, _name2__, _NamedBase, notOverloaded
 from pygeodesy.namedTuples import LatLon3Tuple, LatLon4Tuple, Vector3Tuple
 from pygeodesy.props import Property, Property_RO, property_doc_, property_RO, \
                            _update_all
@@ -42,25 +44,15 @@ from pygeodesy.vector3d import _ALL_LAZY, Vector3d
 # from math import fabs, floor as _floor  # from .fmath, .fsums
 
 __all__ = _ALL_LAZY.ltp
-__version__ = '24.04.23'
+__version__ = '24.06.07'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
 _wide_    = 'wide'
-_Xyz_     = 'Xyz'
-
-
-def _fov_2(**fov):
-    # Half a field-of-view angle in C{degrees}.
-    f = Degrees(Error=LocalError, **fov) * _0_5
-    if EPS < f < _90_0:
-        return f
-    t = _invalid_ if f < 0 else _too_(_wide_ if f > EPS else _narrow_)
-    raise LocalError(txt=t, **fov)
 
 
 class Attitude(_NamedBase):
-    '''The orientation of a plane or camera in space.
+    '''The pose of a plane or camera in space.
     '''
     _alt  = Meter(  alt =_0_0)
     _roll = Degrees(roll=_0_0)
@@ -70,9 +62,9 @@ class Attitude(_NamedBase):
     def __init__(self, alt_attitude=INT0, tilt=INT0, yaw=INT0, roll=INT0, **name):
         '''New L{Attitude}.
 
-           @kwarg alt_attitude: An altitude (C{meter}) above earth or an attitude
-                                (L{Attitude} or L{Attitude4Tuple}) with the
-                                C{B{alt}itude}, B{C{tilt}}, B{C{yaw}} and B{C{roll}}.
+           @kwarg alt_attitude: Altitude (C{meter}) above earth or previous attitude
+                      (L{Attitude} or L{Attitude4Tuple}) with the C{B{alt}itude},
+                      B{C{tilt}}, B{C{yaw}} and B{C{roll}}.
            @kwarg tilt: Pitch, elevation from horizontal (C{degrees180}), negative down
                         (clockwise rotation along and around the x- or East axis).
            @kwarg yaw: Bearing, heading (compass C{degrees360}), clockwise from North
@@ -149,23 +141,26 @@ class Attitude(_NamedBase):
 
     bank = roll
 
-    def rotate(self, x_xyz, y=None, z=None, Vector=None, **Vector_kwds):
+    def rotate(self, x_xyz, y=None, z=None, Vector=None, **name_Vector_kwds):
         '''Transform a (local) cartesian by this attitude's matrix.
 
-           @arg x_xyz: X component of vector (C{scalar}) or (3-D) vector
-                       (C{Cartesian}, L{Vector3d} or L{Vector3Tuple}).
+           @arg x_xyz: X component of vector (C{scalar}) or (3-D) vector (C{Cartesian},
+                       L{Vector3d} or L{Vector3Tuple}).
            @kwarg y: Y component of vector (C{scalar}), same units as B{C{x}}.
            @kwarg z: Z component of vector (C{scalar}), same units as B{C{x}}.
-           @kwarg Vector: Class to return transformed point (C{Cartesian},
-                          L{Vector3d} or C{Vector3Tuple}) or C{None}.
-           @kwarg Vector_kwds: Optional, additional B{C{Vector}} keyword arguments,
-                               ignored if C{B{Vector} is None}.
+           @kwarg Vector: Class to return transformed point (C{Cartesian}, L{Vector3d}
+                          or C{Vector3Tuple}) or C{None}.
+           @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                       additional B{C{Vector}} keyword arguments, ignored if
+                       C{B{Vector} is None}.
 
-           @return: A B{C{Vector}} instance or a L{Vector3Tuple}C{(x, y, z)} if
-                    C{B{Vector}=None}.
+           @return: A named B{C{Vector}} instance or if B{C{Vector}} is C{None},
+                    a named L{Vector3Tuple}C{(x, y, z)}.
 
            @raise AttitudeError: Invalid B{C{x_xyz}}, B{C{y}} or B{C{z}}.
 
+           @raise TypeError: Invalid B{C{Vector}} or B{C{name_Vector_kwds}}.
+
            @see: U{Yaw, pitch, and roll rotations<http://MSL.CS.UIUC.edu/planning/node102.html>}.
         '''
         try:
@@ -177,8 +172,9 @@ class Attitude(_NamedBase):
             raise AttitudeError(x_xyz=x_xyz, y=y, z=z, cause=x)
 
         x, y, z = (fdot(r, *xyz) for r in self.matrix)
-        return Vector3Tuple(x, y, z, name=self.name) if Vector is None else \
-                     Vector(x, y, z, **_xkwds(Vector_kwds, name=self.name))
+        n, kwds = _name2__(name_Vector_kwds, _or_nameof=self)
+        return Vector3Tuple(x, y, z, name=n) if Vector is None else \
+                     Vector(x, y, z, name=n, **kwds)
 
     @property_doc_(' tilt/pitch/elevation from horizontal in C{degrees180}, negative down.')
     def tilt(self):
@@ -469,29 +465,34 @@ class LocalCartesian(_NamedBase):
         '''
         return self._ecef
 
-    def _ecef2local(self, ecef, Xyz, Xyz_kwds):
+    def _ecef2local(self, ecef, Xyz, name_Xyz_kwds):
         '''(INTERNAL) Convert geocentric/geodetic to local, like I{forward}.
 
            @arg ecef: Geocentric (and geodetic) (L{Ecef9Tuple}).
            @arg Xyz: An L{XyzLocal}, L{Enu} or L{Ned} I{class} or C{None}.
-           @arg Xyz_kwds: B{C{Xyz}} keyword arguments, ignored if C{B{Xyz} is None}.
+           @arg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                     additional B{C{Xyz}} keyword arguments, ignored if
+                     C{B{Xyz} is None}.
 
-           @return: An C{B{Xyz}(x, y, z, ltp, **B{Xyz_kwds}} instance or if
-                    C{B{Xyz} is None}, a L{Local9Tuple}C{(x, y, z, lat, lon,
+           @return: An C{B{Xyz}(x, y, z, ltp, **B{name_Xyz_kwds}} instance or
+                    if C{B{Xyz} is None}, a L{Local9Tuple}C{(x, y, z, lat, lon,
                     height, ltp, ecef, M)} with this C{ltp}, B{C{ecef}}
                     (L{Ecef9Tuple}) converted to this C{datum} and C{M=None},
                     always.
+
+           @raise TypeError: Invalid B{C{Xyz}} or B{C{name_Xyz_kwds}}.
         '''
+        _xinstanceof(Ecef9Tuple, ecef=ecef)
         ltp = self
         if ecef.datum != ltp.datum:
             ecef = ecef.toDatum(ltp.datum)
-        x, y, z = self.M.rotate(ecef.xyz, *ltp._t0_xyz)
+        n, kwds = _name2__(name_Xyz_kwds, _or_nameof=ecef)
+        x, y, z =  self.M.rotate(ecef.xyz, *ltp._t0_xyz)
         r = Local9Tuple(x, y, z, ecef.lat, ecef.lon, ecef.height,
-                                 ltp, ecef, None, name=ecef.name)
+                                 ltp, ecef, None, name=n)
         if Xyz:
-            if not issubclassof(Xyz, *_XyzLocals4):  # Vector3d
-                raise _TypesError(_Xyz_, Xyz, *_XyzLocals4)
-            r = r.toXyz(Xyz=Xyz, **Xyz_kwds)
+            _xsubclassof(*_XyzLocals4, Xyz=Xyz)  # Vector3d
+            r = r.toXyz(Xyz=Xyz, name=n, **kwds)
         return r
 
     @Property_RO
@@ -554,13 +555,14 @@ class LocalCartesian(_NamedBase):
         '''(INTERNAL) Convert I{local} to geocentric/geodetic, like I{.reverse}.
 
            @arg local: Local (L{XyzLocal}, L{Enu}, L{Ned}, L{Aer} or L{Local9Tuple}).
-           @kwarg nine: Return 3- or 9-tuple (C{bool}).
+           @kwarg nine: If C{True}, return a 9-, otherwise a 3-tuple (C{bool}).
            @kwarg M: Include the rotation matrix (C{bool}).
 
            @return: A I{geocentric} 3-tuple C{(x, y, z)} or if C{B{nine}=True},
                     an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)},
-                    optionally including rotation matrix C{M} or C{None}.
+                    optionally including rotation matrix C{M} otherwise C{None}.
         '''
+        _xinstanceof(*_XyzLocals5, local=local)
         t = self.M.unrotate(local.xyz, *self._t0_xyz)
         if nine:
             t = self.ecef.reverse(*t, M=M)
@@ -1065,8 +1067,30 @@ class ChLVe(_ChLV, LocalCartesian):
         return t
 
 
-def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **Vector_kwds):
-    '''Convert an attitude oriention into a (3-D) direction vector.
+def _fov_2(**fov):
+    # Half a field-of-view angle in C{degrees}.
+    f = Degrees(Error=LocalError, **fov) * _0_5
+    if EPS < f < _90_0:
+        return f
+    t = _invalid_ if f < 0 else _too_(_wide_ if f > EPS else _narrow_)
+    raise LocalError(txt=t, **fov)
+
+
+def _toLocal(inst, ltp, Xyz, Xyz_kwds):
+    '''(INTENRAL) Helper for C{CartesianBase.toLocal} and C{latLonBase.toLocal}.
+    '''
+    return _xLtp(ltp, inst._Ltp)._ecef2local(inst._ecef9, Xyz, Xyz_kwds)
+
+
+def _toLtp(inst, Ecef, ecef9, name):
+    '''(INTENRAL) Helper for C{CartesianBase.toLtp} and C{latLonBase.toLtp}.
+    '''
+    return inst._Ltp if Ecef in (None, inst.Ecef) and not name else \
+                 Ltp(ecef9, ecef=Ecef(inst.datum), name=inst._name__(name))
+
+
+def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector_kwds):
+    '''Convert an attitude pose into a (3-D) direction vector.
 
        @kwarg tilt: Pitch, elevation from horizontal (C{degrees}), negative down
                     (clockwise rotation along and around the x-axis).
@@ -1074,27 +1098,41 @@ def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **Vector_kwds):
                    (counter-clockwise rotation along and around the z-axis).
        @kwarg roll: Roll, bank (C{degrees}), positive to the right and down
                     (clockwise rotation along and around the y-axis).
+       @kwarg Vector: Class to return the direction vector (C{Cartesian},
+                      L{Vector3d} or C{Vector3Tuple}) or C{None}.
+       @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                   additional B{C{Vector}} keyword arguments, ignored if
+                   C{B{Vector} is None}.
 
        @return: A named B{C{Vector}} instance or if B{C{Vector}} is C{None},
                 a named L{Vector3Tuple}C{(x, y, z)}.
 
+       @raise AttitudeError: Invalid B{C{tilt}}, B{C{yaw}} or B{C{roll}}.
+
+       @raise TypeError: Invalid B{C{Vector}} or B{C{name_Vector_kwds}}.
+
        @see: U{Yaw, pitch, and roll rotations<http://MSL.CS.UIUC.edu/planning/node102.html>}
-             and function L{pygeodesy.hartzell} argument C{los}.
+             and function L{pygeodesy.hartzell} argument C{los}, Line-Of-Sight.
     '''
-    d = Attitude4Tuple(_0_0, tilt, yaw, roll).tyr3d
-    return d if Vector is type(d) else (
-           Vector3Tuple(d.x, d.y, d.z, name=d.name) if Vector is None else
-                 Vector(d.x, d.y, d.z, **_xkwds(Vector_kwds, name=d.name)))  # PYCHOK indent
+    v = Attitude4Tuple(_0_0, tilt, yaw, roll).tyr3d
+    if Vector is not type(v):
+        n, kwds = _name2__(name_Vector_kwds, name__=tyr3d)
+        v = Vector3Tuple(v.x, v.y, v.z, name=n) if Vector is None else \
+                  Vector(v.x, v.y, v.z, name=n, **kwds)
+    elif name_Vector_kwds:
+        n, _ = _name2__(name_Vector_kwds)
+        if n:
+            v = v.copy(name=n)
+    return v
 
 
 def _xLtp(ltp, *dflt):
-    '''(INTERNAL) Validate B{C{ltp}}.
+    '''(INTERNAL) Validate B{C{ltp}} or ist B{C{dflt}}.
     '''
     if dflt and ltp is None:
         ltp = dflt[0]
-    if isinstance(ltp, (LocalCartesian, Ltp)):
-        return ltp
-    raise _TypesError(_ltp_, ltp, Ltp, LocalCartesian)
+    _xinstanceof(Ltp, LocalCartesian, ltp=ltp)
+    return ltp
 
 # **) MIT License
 #