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

pygeodesy/geohash.py

@@ -297,20 +297,20 @@ class Geohash(Str):
            using function L{pygeodesy.equirectangular}.
 
            @arg other: The other geohash (L{Geohash}, C{LatLon} or C{str}).
-           @kwarg radius: Mean earth radius, ellipsoid or datum
-                          (C{meter}, L{Ellipsoid}, L{Ellipsoid2},
-                          L{Datum} or L{a_f2Tuple}) or C{None}.
-           @kwarg adjust_limit_wrap: Optional keyword arguments for
-                               function L{pygeodesy.equirectangular_},
-                               overriding defaults C{B{adjust}=False,
-                               B{limit}=None} and C{B{wrap}=False}.
+           @kwarg radius: Mean earth radius, ellipsoid or datum (C{meter},
+                          L{Ellipsoid}, L{Ellipsoid2}, L{Datum} or
+                          L{a_f2Tuple}) or C{None}, see function
+                          L{pygeodesy.equirectangular}.
+           @kwarg adjust_limit_wrap: Optional keyword arguments for function
+                         L{pygeodesy.equirectangular4}, overriding defaults
+                         C{B{adjust}=False, B{limit}=None} and C{B{wrap}=False}.
 
            @return: Distance (C{meter}, same units as B{C{radius}} or the
                     ellipsoid or datum axes or C{radians I{squared}} if
                     B{C{radius}} is C{None} or C{0}).
 
-           @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon}
-                             or C{str} or invalid B{C{radius}}.
+           @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon} or
+                             C{str} or invalid B{C{radius}}.
 
            @see: U{Local, flat earth approximation
                  <https://www.EdWilliams.org/avform.htm#flat>}, functions
@@ -319,7 +319,7 @@ class Geohash(Str):
         kwds = _xkwds(adjust_limit_wrap, adjust=False, limit=None, wrap=False)
         m    =  self._formy
         return m.equirectangular( *lls, radius=radius, **kwds) if radius else \
-               m.equirectangular_(*lls, **kwds).distance2
+               m.equirectangular4(*lls, **kwds).distance2
 
     def euclideanTo(self, other, **radius_adjust_wrap):
         '''Approximate the distance between this and an other geohash using
@@ -645,8 +645,8 @@ def distance1(geohash1, geohash2):
 
 @deprecated_function
 def distance2(geohash1, geohash2):
-    '''DEPRECATED, use L{geohash.equirectangular_}.'''
-    return equirectangular_(geohash1, geohash2)
+    '''DEPRECATED, use L{geohash.equirectangular4}.'''
+    return equirectangular4(geohash1, geohash2)
 
 
 @deprecated_function
@@ -718,7 +718,7 @@ def encode(lat, lon, precision=None):
     return NN.join(gh)
 
 
-def equirectangular_(geohash1, geohash2, radius=R_M):
+def equirectangular4(geohash1, geohash2, radius=R_M):
     '''Approximate the distance between two geohashes using the
        L{pygeodesy.equirectangular} formula.
 
@@ -891,7 +891,7 @@ def vincentys_(geohash1, geohash2, **radius_wrap):
 
 __all__ += _ALL_OTHER(bounds,  # functions
                       decode, decode2, decode_error, distance_,
-                      encode, equirectangular_, euclidean_, haversine_,
+                      encode, equirectangular4, euclidean_, haversine_,
                       neighbors, precision, resolution2, sizes, vincentys_)
 
 # **) MIT License

pygeodesy/hausdorff.py

@@ -77,7 +77,7 @@ from pygeodesy.lazily import _ALL_LAZY, _FOR_DOCS
 from pygeodesy.named import _name2__, _Named, _NamedTuple, _Pass
 # from pygeodesy.namedTuples import PhiLam2Tuple  # from .points
 from pygeodesy.points import _distanceTo, points2 as _points2,  PhiLam2Tuple, radians
-from pygeodesy.props import Property_RO, property_doc_, property_RO
+from pygeodesy.props import Property, Property_RO, property_doc_, property_RO
 from pygeodesy.units import Float, Number_, _xUnit, _xUnits
 from pygeodesy.unitsBase import _Str_degrees, _Str_degrees2, _Str_meter, _Str_NN, \
                                 _Str_radians, _Str_radians2
@@ -86,7 +86,7 @@ from pygeodesy.unitsBase import _Str_degrees, _Str_degrees2, _Str_meter, _Str_NN
 from random import Random
 
 __all__ = _ALL_LAZY.hausdorff
-__version__ = '24.05.24'
+__version__ = '24.05.26'
 
 
 class HausdorffError(PointsError):
@@ -179,14 +179,14 @@ class Hausdorff(_Named):
         return self._func(point1.lat, point1.lon,
                           point2.lat, point2.lon, **self._kwds)
 
-    @property
+    @Property
     def _func(self):
         '''(INTERNAL) I{Must be overloaded}.'''
-        return _formy._Propy(self, 0, _func=None)
+        self._notOverloaded(**self.kwds)
 
-    @_func.setter  # PYCHOK setter!
+    @_func.setter_  # PYCHOK setter_underscore!
     def _func(self, func):
-        _formy._Propy(self, 4, _func=func)
+        return _formy._Propy(func, 4, self.kwds)
 
     def _hausdorff_(self, point2s, both, early, distance):
         _, ps2 = self._points2(point2s)
@@ -341,14 +341,14 @@ class _HausdorffMeterRadians(Hausdorff):
         '''
         return self._hausdorff_(point2s, True, early, _formy._radistance(self))
 
-    @property
+    @Property
     def _func_(self):
         '''(INTERNAL) I{Must be overloaded}.'''
-        return _formy._Propy(self, 0, _func_=None)
+        self._notOverloaded(**self.kwds)
 
-    @_func_.setter  # PYCHOK setter!
+    @_func_.setter_  # PYCHOK setter_underscore!
     def _func_(self, func):
-        _formy._Propy(self, 3,_func_=func)
+        return _formy._Propy(func, 3, self.kwds)
 
 
 class HausdorffCosineAndoyerLambert(_HausdorffMeterRadians):
@@ -462,7 +462,7 @@ class HausdorffDistanceTo(Hausdorff):
 
 class HausdorffEquirectangular(Hausdorff):
     '''Compute the C{Hausdorff} distance based on the C{equirectangular} distance
-       in C{radians squared} like function L{pygeodesy.equirectangular_}.
+       in C{radians squared} like function L{pygeodesy.equirectangular}.
     '''
     _units = _Str_degrees2
 
@@ -471,7 +471,7 @@ class HausdorffEquirectangular(Hausdorff):
 
            @kwarg seed_name__adjust_limit_wrap: Optional C{B{seed}=None} and
                              C{B{name}=NN} and keyword arguments for function
-                             L{pygeodesy.equirectangular_} I{with default}
+                             L{pygeodesy.equirectangular} I{with default}
                              C{B{limit}=0} for I{backward compatibility}.
 
            @see: L{Hausdorff.__init__} for details about B{C{point1s}},

pygeodesy/heights.py

@@ -75,7 +75,7 @@ from pygeodesy.errors import _AssertionError, LenError, PointsError, \
                              _SciPyIssue, _xattr, _xkwds, _xkwds_get, _xkwds_item2
 # from pygeodesy.fmath import fidw  # _MODS
 # from pygeodesy.formy import cosineAndoyerLambert, cosineForsytheAndoyerLambert, \
-#                             cosineLaw, equirectangular_, euclidean, flatLocal, \
+#                             cosineLaw, equirectangular4, euclidean, flatLocal, \
 #                             flatPolar, haversine, thomas, vincentys  # _MODS
 # from pygeodesy.internals import _version2  # _MODS
 from pygeodesy.interns import NN, _COMMASPACE_, _cubic_, _insufficient_, _linear_, \
@@ -91,7 +91,7 @@ from pygeodesy.units import _isDegrees, Float_, Int_
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.heights
-__version__ = '24.05.23'
+__version__ = '24.05.25'
 
 _error_     = 'error'
 _llis_      = 'llis'
@@ -898,14 +898,14 @@ class HeightIDWequirectangular(_HeightIDW):
     '''Height interpolator using U{Inverse Distance Weighting
        <https://WikiPedia.org/wiki/Inverse_distance_weighting>} (IDW) and
        the I{angular} distance in C{radians squared} like function
-       L{pygeodesy.equirectangular_}.
+       L{pygeodesy.equirectangular4}.
     '''
     def __init__(self, knots, beta=2, **name__adjust_limit_wrap):  # XXX beta=1
         '''New L{HeightIDWequirectangular} interpolator.
 
            @kwarg name__adjust_limit_wrap: Optional C{B{name}=NN} for this
                         height interpolator (C{str}) and keyword arguments
-                        for function L{pygeodesy.equirectangular_}.
+                        for function L{pygeodesy.equirectangular4}.
 
            @see: L{Here<_HeightIDW.__init__>} for further details.
         '''
@@ -914,7 +914,7 @@ class HeightIDWequirectangular(_HeightIDW):
     def _distances(self, x, y):
         '''(INTERNAL) Yield distances to C{(x, y)}.
         '''
-        _f, kwds = self._formy.equirectangular_, self._kwds
+        _f, kwds = self._formy.equirectangular4, self._kwds
         try:
             for i, k in enumerate(self._knots):
                 yield _f(y, x, k.lat, k.lon, **kwds).distance2

pygeodesy/internals.py

@@ -543,15 +543,15 @@ def _version_ints(vs):
 
 
 __all__ = tuple(map(_dunder_nameof, (machine, print_, printf)))
-__version__ = '24.05.21'
+__version__ = '24.05.25'
 
 if _dunder_ismain(__name__):  # PYCHOK no cover
 
     from pygeodesy import _isfrozen, isLazy, version as vs
 
     print_(_pygeodesy_, vs, *(_Pythonarchine() + _osversion2()
-                                               + ['isfrozen', _isfrozen,
-                                                  'isLazy',    isLazy]))
+                                               + ['_isfrozen', _isfrozen,
+                                                  'isLazy',     isLazy]))
 
 # **) MIT License
 #

pygeodesy/karney.py

@@ -143,12 +143,13 @@ from pygeodesy.basics import _copysign, int1s, isint, itemsorted, neg, unsigned0
                              _xgeographiclib, _zip,  _version_info
 from pygeodesy.constants import NAN, _isfinite as _math_isfinite, _0_0, \
                                _1_16th, _1_0, _2_0, _180_0, _N_180_0, _360_0
-from pygeodesy.errors import GeodesicError, _ValueError, _xkwds, _xkwds_get
+from pygeodesy.errors import GeodesicError, _ValueError, _xkwds, _xkwds_get1
 from pygeodesy.fmath import cbrt, fremainder, norm2
 # from pygeodesy.internals import _version_info  # from .basics
-from pygeodesy.interns import NN, _2_, _a12_, _area_, _azi2_, _azi12_, _composite_, \
-                             _lat1_, _lat2_, _lon1_, _lon2_, _m12_, _M12_, _M21_, \
-                             _number_, _s12_, _S12_, _UNDER_, _BAR_  # PYCHOK used!
+from pygeodesy.interns import _2_, _a12_, _area_, _azi2_, _azi12_, _composite_, \
+                              _lat1_, _lat2_, _lon1_, _lon2_, _m12_, _M12_, \
+                              _M21_, _number_, _s12_, _S12_, _UNDER_, \
+                              _BAR_, NN  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv
 from pygeodesy.named import ADict, _NamedBase, _NamedTuple, notImplemented, _Pass
 from pygeodesy.props import deprecated_method, Property_RO
@@ -159,7 +160,7 @@ from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '24.05.20'
+__version__ = '24.05.31'
 
 _K_2_0      = _getenv('PYGEODESY_GEOGRAPHICLIB', _2_) == _2_
 _perimeter_ = 'perimeter'
@@ -171,7 +172,7 @@ class _GTuple(_NamedTuple):  # in .testNamedTuples
     def toGDict(self, **updates):  # NO name=NN
         '''Convert this C{*Tuple} to a L{GDict}.
 
-           @kwarg updates: Optional items to apply (C{nam=value} pairs)
+           @kwarg updates: Optional items to apply (C{name=value} pairs)
         '''
         r = GDict(_zip(self._Names_, self))  # strict=True
         if updates:
@@ -845,7 +846,7 @@ def _sum2_(s, t, *vs, **x):
 
        @note: NOT "error-free", see C{pygeodesy.test/testKarney.py}.
     '''
-    x = _xkwds_get(x, x=_1_0)
+    x = _xkwds_get1(x, x=_1_0)
     p =  x != _1_0
 
     _s2, _u0 = _sum2, unsigned0

pygeodesy/lazily.py

@@ -269,7 +269,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_',
@@ -421,7 +421,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',

pygeodesy/ltp.py

@@ -13,7 +13,7 @@ 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, _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!
@@ -29,7 +29,7 @@ from pygeodesy.interns import _0_, _COMMASPACE_, _DOT_, _ecef_, _height_, _M_, \
 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 +42,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.05.31'
 
 _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 +60,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 +139,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 +170,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 +463,33 @@ 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}}.
         '''
         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,7 +552,7 @@ 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},
@@ -1065,8 +1063,17 @@ 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 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,17 +1081,28 @@ 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
+    if Vector is not type(d):
+        n, kwds = _name2__(name_Vector_kwds, name__=tyr3d)
+        d = Vector3Tuple(d.x, d.y, d.z, name=n) if Vector is None else \
+                  Vector(d.x, d.y, d.z, name=n, **kwds)
+    return d
 
 
 def _xLtp(ltp, *dflt):