dca type annotation

Author: scivision

src/pymap3d/dca.py

@@ -23,6 +23,8 @@
 
 from __future__ import annotations
 
+from ._typing import FloatLike
+
 from .mathfun import sin, cos, radians
 from .ecef import ecef2enu, enu2ecef
 from .enu import geodetic2enu, enu2geodetic, aer2enu, enu2aer
@@ -42,7 +44,7 @@
 ]
 
 
-def enu2dca(e, n, u, heading, deg: bool = True):
+def enu2dca(e: FloatLike, n: FloatLike, u: FloatLike, heading: FloatLike, deg: bool = True):
     """
     Converts ENU (East, North, Up) coordinates to DCA (Downrange, Crossrange, Above).
     """
@@ -56,7 +58,7 @@ def enu2dca(e, n, u, heading, deg: bool = True):
     return dr, cr, u
 
 
-def dca2enu(dr, cr, above, heading, deg: bool = True):
+def dca2enu(dr: FloatLike, cr: FloatLike, above: FloatLike, heading: FloatLike, deg: bool = True):
     """
     Converts DCA (Downrange, Crossrange, Above) coordinates to ENU (East, North, Up).
     """
@@ -70,23 +72,33 @@ def dca2enu(dr, cr, above, heading, deg: bool = True):
     return e, n, above
 
 
-def dca2ned(dr, cr, above, heading, deg: bool = True):
+def dca2ned(dr: FloatLike, cr: FloatLike, above: FloatLike, heading: FloatLike, deg: bool = True):
     """
     Converts DCA (Downrange, Crossrange, Above) coordinates to NED (North, East, Down).
     """
     e, n, u = dca2enu(dr, cr, above, heading, deg=deg)
     return n, e, -u
 
 
-def ned2dca(n, e, d, heading, deg: bool = True):
+def ned2dca(n: FloatLike, e: FloatLike, d: FloatLike, heading: FloatLike, deg: bool = True):
     """
     Converts NED (North, East, Down) coordinates to DCA (Downrange, Crossrange, Above).
     """
     dr, cr, above = enu2dca(e, n, -d, heading, deg=deg)
     return dr, cr, above
 
 
-def ecef2dca(x, y, z, lat0, lon0, h0, heading, ell: Ellipsoid | None = None, deg: bool = True):
+def ecef2dca(
+    x: FloatLike,
+    y: FloatLike,
+    z: FloatLike,
+    lat0: FloatLike,
+    lon0: FloatLike,
+    h0: FloatLike,
+    heading: FloatLike,
+    ell: Ellipsoid | None = None,
+    deg: bool = True,
+):
     """
     Converts ECEF (Earth-Centered, Earth-Fixed) coordinates to DCA (Downrange, Crossrange, Above).
     """
@@ -96,13 +108,13 @@ def ecef2dca(x, y, z, lat0, lon0, h0, heading, ell: Ellipsoid | None = None, deg
 
 
 def dca2ecef(
-    dr,
-    cr,
-    above,
-    lat0,
-    lon0,
-    h0,
-    heading,
+    dr: FloatLike,
+    cr: FloatLike,
+    above: FloatLike,
+    lat0: FloatLike,
+    lon0: FloatLike,
+    h0: FloatLike,
+    heading: FloatLike,
     ell: Ellipsoid | None = None,
     deg: bool = True,
 ):
@@ -115,7 +127,15 @@ def dca2ecef(
 
 
 def geodetic2dca(
-    lat, lon, h, lat0, lon0, h0, heading, ell: Ellipsoid | None = None, deg: bool = True
+    lat: FloatLike,
+    lon: FloatLike,
+    h: FloatLike,
+    lat0: FloatLike,
+    lon0: FloatLike,
+    h0: FloatLike,
+    heading: FloatLike,
+    ell: Ellipsoid | None = None,
+    deg: bool = True,
 ):
     """
     Converts geodetic coordinates (latitude, longitude, altitude) to DCA (Downrange, Crossrange, Above) coordinates.
@@ -125,13 +145,13 @@ def geodetic2dca(
 
 
 def dca2geodetic(
-    dr,
-    cr,
-    above,
-    lat0,
-    lon0,
-    h0,
-    heading,
+    dr: FloatLike,
+    cr: FloatLike,
+    above: FloatLike,
+    lat0: FloatLike,
+    lon0: FloatLike,
+    h0: FloatLike,
+    heading: FloatLike,
     ell: Ellipsoid | None = None,
     deg: bool = True,
 ):
@@ -142,15 +162,15 @@ def dca2geodetic(
     return enu2geodetic(e, n, u, lat0, lon0, h0, ell, deg=deg)
 
 
-def aer2dca(az, el, srange, heading, deg: bool = True):
+def aer2dca(az: FloatLike, el: FloatLike, srange: FloatLike, heading: FloatLike, deg: bool = True):
     """
     Converts AER (Azimuth, Elevation, Range) coordinates to DCA (Downrange, Crossrange, Above).
     """
     e, n, u = aer2enu(az, el, srange, deg=deg)
     return enu2dca(e, n, u, heading, deg=deg)
 
 
-def dca2aer(dr, cr, above, heading, deg: bool = True):
+def dca2aer(dr: FloatLike, cr: FloatLike, above: FloatLike, heading: FloatLike, deg: bool = True):
     """
     Converts DCA (Downrange, Crossrange, Above) coordinates to AER (Azimuth, Elevation, Range).
     """

src/pymap3d/ecef.py

@@ -88,9 +88,9 @@ def geodetic2ecef(
 
 
 def ecef2geodetic(
-    x: FloatArray,
-    y: FloatArray,
-    z: FloatArray,
+    x: FloatLike | FloatArray,
+    y: FloatLike | FloatArray,
+    z: FloatLike | FloatArray,
     ell: Ellipsoid | None = None,
     deg: bool = True,
 ) -> tuple:
@@ -138,7 +138,7 @@ def ecef2geodetic(
 
     huE = hypot(u, E)
 
-    def _inside_numpy(x: FloatArray, y: FloatArray, z: FloatArray):
+    def _inside_numpy(x, y, z) -> NDArray:
         # inside ellipsoid?
         return (
             x**2 / ell.semimajor_axis**2
@@ -156,7 +156,7 @@ def _inside_scalar(x: float, y: float, z: float) -> bool:
             < 1
         )
 
-    def _lat_alt_numpy(x: NDArray, y: NDArray, z: NDArray, Beta: NDArray) -> tuple:
+    def _lat_alt_numpy(x, y, z, Beta) -> tuple:
         """eqation 4c using Numpy"""
         lat = atan(ell.semimajor_axis / ell.semiminor_axis * tan(Beta))
         # patch latitude for float32 precision loss

src/pymap3d/nvector.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
+from ._typing import FloatLike
 from .mathfun import degrees, radians, sin, cos, atan2, asin
 from .ecef import geodetic2ecef, ecef2geodetic
 from .ellipsoid import Ellipsoid
 
 
-def geodetic2nvector(lat, lon, deg: bool = True) -> tuple:
+def geodetic2nvector(lat: FloatLike, lon: FloatLike, deg: bool = True) -> tuple:
     """
     Convert geodetic coordinates (latitude, longitude) to an n-vector.
 
@@ -37,7 +38,7 @@ def geodetic2nvector(lat, lon, deg: bool = True) -> tuple:
     return n1, n2, n3
 
 
-def nvector2geodetic(n1, n2, n3, deg=True) -> tuple:
+def nvector2geodetic(n1: FloatLike, n2: FloatLike, n3: FloatLike, deg: bool = True) -> tuple:
     """
     Convert an n-vector back to geodetic coordinates (latitude, longitude).
 
@@ -64,7 +65,9 @@ def nvector2geodetic(n1, n2, n3, deg=True) -> tuple:
     return lat, lon
 
 
-def ecef2nvector(x, y, z, ell: Ellipsoid | None = None, deg: bool = True):
+def ecef2nvector(
+    x: FloatLike, y: FloatLike, z: FloatLike, ell: Ellipsoid | None = None, deg: bool = True
+):
     """
     Convert ECEF coordinates to an n-vector.
 
@@ -85,7 +88,14 @@ def ecef2nvector(x, y, z, ell: Ellipsoid | None = None, deg: bool = True):
     return geodetic2nvector(lat, lon, deg=deg)
 
 
-def nvector2ecef(n1, n2, n3, alt=0, ell: Ellipsoid | None = None, deg: bool = True):
+def nvector2ecef(
+    n1: FloatLike,
+    n2: FloatLike,
+    n3: FloatLike,
+    alt: FloatLike = 0,
+    ell: Ellipsoid | None = None,
+    deg: bool = True,
+):
     """
     Convert an n-vector to ECEF coordinates.
 

src/pymap3d/sidereal.py

@@ -8,7 +8,7 @@
 import logging
 
 from .timeconv import str2dt
-from ._typing import  FloatLike, DatetimeLike
+from ._typing import FloatLike, DatetimeLike
 
 try:
     import astropy.units as u

src/pymap3d/tests/test_dca.py

@@ -21,12 +21,25 @@ def get_ellipsoid_params():
 )
 def test_enu_dca(enu, dca, heading):
 
-    assert pm.dca2enu(*dca, heading) == pytest.approx(enu)
-    assert pm.enu2dca(*enu, heading) == pytest.approx(dca)
+    assert pm.dca2enu(*dca, heading=heading) == pytest.approx(enu)
+    assert pm.enu2dca(*enu, heading=heading) == pytest.approx(dca)
 
     ned = enu[1], enu[0], -enu[2]
-    assert pm.dca2ned(*dca, heading) == pytest.approx(ned)
-    assert pm.ned2dca(*ned, heading) == pytest.approx(dca)
+    assert pm.dca2ned(*dca, heading=heading) == pytest.approx(ned)
+    assert pm.ned2dca(*ned, heading=heading) == pytest.approx(dca)
+
+
+def test_enu_dca_numpy():
+    np = pytest.importorskip("numpy")
+    e = np.array([0, 0, 0])
+    n = np.array([0, 0, 0])
+    u = np.array([0, 0, 0])
+    d = np.array([0, 0, 0])
+    c = np.array([0, 0, 0])
+    a = np.array([0, 0, 0])
+    heading = 15
+    assert pm.dca2enu(d, c, a, heading=heading) == pytest.approx((0, 0, 0))
+    assert pm.enu2dca(e, n, u, heading=heading) == pytest.approx((0, 0, 0))
 
 
 @pytest.mark.parametrize(

src/pymap3d/tests/test_enu.py

@@ -28,15 +28,26 @@ def test_scalar_enu(xyz):
 def test_array_enu():
     np = pytest.importorskip("numpy")
 
-    xyz = (np.asarray(0), np.asarray(A), np.asarray(50))
-    llh = (np.asarray(0), np.asarray(90), np.asarray(-100))
-    enu = pm.ecef2enu(*xyz, *llh)
-    assert pm.enu2ecef(*enu, *llh) == approx(xyz)
+    x = np.asarray(0)
+    y = np.asarray(A)
+    z = np.asarray(50)
+    lat = np.asarray(0)
+    lon = np.asarray(90)
+    h = np.asarray(-100)
 
-    xyz = (np.atleast_1d(0), np.atleast_1d(A), np.atleast_1d(50))
-    llh = (np.atleast_1d(0), np.atleast_1d(90), np.atleast_1d(-100))
-    enu = pm.ecef2enu(*xyz, *llh)
-    assert pm.enu2ecef(*enu, *llh) == approx(xyz)
+    e, n, u = pm.ecef2enu(x, y, z, lat, lon, h)
+
+    assert pm.enu2ecef(e, n, u, lat, lon, h) == approx((x, y, z))
+
+    x = np.atleast_1d(0)
+    y = np.atleast_1d(A)
+    z = np.atleast_1d(50)
+    lat = np.atleast_1d(0)
+    lon = np.atleast_1d(90)
+    h = np.atleast_1d(-100)
+
+    e, n, u = pm.ecef2enu(x, y, z, lat, lon, h)
+    assert pm.enu2ecef(e, n, u, lat, lon, h) == approx((x, y, z))
 
 
 @pytest.mark.parametrize(
@@ -52,8 +63,11 @@ def test_enu_ecef(enu, lla, xyz):
     assert isinstance(y, float)
     assert isinstance(z, float)
 
-    rlla = (radians(lla[0]), radians(lla[1]), lla[2])
-    assert pm.enu2ecef(*enu, *rlla, deg=False) == approx(xyz)
+    rlat = radians(lla[0])
+    rlon = radians(lla[1])
+    rh = lla[2]
+
+    assert pm.enu2ecef(*enu, rlat, rlon, rh, deg=False) == approx(xyz)
 
     e, n, u = pm.ecef2enu(*xyz, *lla)
     assert e == approx(enu[0])
@@ -63,7 +77,7 @@ def test_enu_ecef(enu, lla, xyz):
     assert isinstance(n, float)
     assert isinstance(u, float)
 
-    e, n, u = pm.ecef2enu(*xyz, *rlla, deg=False)
+    e, n, u = pm.ecef2enu(*xyz, rlat, rlon, rh, deg=False)
     assert e == approx(enu[0])
     assert n == approx(enu[1])
     assert u == approx(enu[2])

src/pymap3d/tests/test_rsphere.py

@@ -22,6 +22,7 @@ def test_rsphere_eqavol():
 def test_rsphere_authalic():
     assert rsphere.authalic() == approx(6371007.1809)
 
+
 def test_rsphere_curve():
     assert rsphere.curve(0) == approx(6356788.163646411)
     assert rsphere.curve(90) == approx(6399593.625758492)