correct type annotation

Author: scivision

src/pymap3d/dca.py

@@ -1,9 +1,9 @@
 """
 Transforms involving DCA (Downrange, Crossrange, Above)
 
-This module provides functions to convert coordinates between DCA and 
+This module provides functions to convert coordinates between DCA and
 other coordinate systems such as ENU (East, North, Up), NED (North, East, Down),
-ECEF (Earth-Centered, Earth-Fixed), and geodetic coordinates (latitude, longitude, altitude). 
+ECEF (Earth-Centered, Earth-Fixed), and geodetic coordinates (latitude, longitude, altitude).
 
 It also includes transformations to/from AER (Azimuth, Elevation, Range).
 
@@ -21,6 +21,8 @@
 - dca2aer: Convert DCA to AER coordinates.
 """
 
+from __future__ import annotations
+
 from .mathfun import sin, cos, radians
 from .ecef import ecef2enu, enu2ecef
 from .enu import geodetic2enu, enu2geodetic, aer2enu, enu2aer
@@ -39,92 +41,102 @@
     "dca2aer",
 ]
 
-ELL = Ellipsoid.from_name("wgs84")  # Default reference ellipsoid (WGS84)
-
 
-def enu2dca(e, n, u, heading, deg=True):
+def enu2dca(e, n, u, heading, deg: bool = True):
     """
     Converts ENU (East, North, Up) coordinates to DCA (Downrange, Crossrange, Above).
     """
+
     if deg:
         heading = radians(heading)
+
     dr = e * sin(heading) + n * cos(heading)
     cr = -e * cos(heading) + n * sin(heading)
-    a = u
-    return dr, cr, a
+
+    return dr, cr, u
 
 
-def dca2enu(dr, cr, a, heading, deg=True):
+def dca2enu(dr, cr, above, heading, deg: bool = True):
     """
     Converts DCA (Downrange, Crossrange, Above) coordinates to ENU (East, North, Up).
     """
+
     if deg:
         heading = radians(heading)
+
     e = dr * sin(heading) - cr * cos(heading)
     n = dr * cos(heading) + cr * sin(heading)
-    u = a
-    return e, n, u
+
+    return e, n, above
 
 
-def dca2ned(dr, cr, a, heading, deg=True):
+def dca2ned(dr, cr, above, heading, deg: bool = True):
     """
     Converts DCA (Downrange, Crossrange, Above) coordinates to NED (North, East, Down).
     """
-    e, n, u = dca2enu(dr, cr, a, heading, deg=deg)
+    e, n, u = dca2enu(dr, cr, above, heading, deg=deg)
     return n, e, -u
 
 
-def ned2dca(n, e, d, heading, deg=True):
+def ned2dca(n, e, d, heading, deg: bool = True):
     """
     Converts NED (North, East, Down) coordinates to DCA (Downrange, Crossrange, Above).
     """
-    dr, cr, a = enu2dca(e, n, -d, heading, deg=deg)
-    return dr, cr, a
+    dr, cr, above = enu2dca(e, n, -d, heading, deg=deg)
+    return dr, cr, above
 
 
-def ecef2dca(x, y, z, lat0, lon0, h0, heading, ell=ELL, deg=True):
+def ecef2dca(x, y, z, lat0, lon0, h0, heading, ell: Ellipsoid | None = None, deg: bool = True):
     """
     Converts ECEF (Earth-Centered, Earth-Fixed) coordinates to DCA (Downrange, Crossrange, Above).
     """
+
     e, n, u = ecef2enu(x, y, z, lat0, lon0, h0, ell, deg=deg)
     return enu2dca(e, n, u, heading, deg=deg)
 
 
-def dca2ecef(dr, cr, a, lat0, lon0, h0, heading, ell=ELL, deg=True):
+def dca2ecef(
+    dr, cr, above, lat0, lon0, h0, heading, ell: Ellipsoid | None = None, deg: bool = True
+):
     """
     Converts DCA (Downrange, Crossrange, Above) coordinates to ECEF (Earth-Centered, Earth-Fixed) coordinates.
     """
-    e, n, u = dca2enu(dr, cr, a, heading, deg=deg)
+
+    e, n, u = dca2enu(dr, cr, above, heading, deg=deg)
     return enu2ecef(e, n, u, lat0, lon0, h0, ell, deg=deg)
 
 
-def geodetic2dca(lat, lon, h, lat0, lon0, h0, heading, ell=ELL, deg=True):
+def geodetic2dca(
+    lat, lon, h, lat0, lon0, h0, heading, ell: Ellipsoid | None = None, deg: bool = True
+):
     """
     Converts geodetic coordinates (latitude, longitude, altitude) to DCA (Downrange, Crossrange, Above) coordinates.
     """
     e, n, u = geodetic2enu(lat, lon, h, lat0, lon0, h0, ell, deg=deg)
     return enu2dca(e, n, u, heading, deg=deg)
 
 
-def dca2geodetic(dr, cr, a, lat0, lon0, h0, heading, ell=ELL, deg=True):
+def dca2geodetic(
+    dr, cr, above, lat0, lon0, h0, heading, ell: Ellipsoid | None = None, deg: bool = True
+):
     """
     Converts DCA (Downrange, Crossrange, Above) coordinates to geodetic coordinates (latitude, longitude, altitude).
     """
-    e, n, u = dca2enu(dr, cr, a, heading, deg=deg)
+    e, n, u = dca2enu(dr, cr, above, heading, deg=deg)
     return enu2geodetic(e, n, u, lat0, lon0, h0, ell, deg=deg)
 
 
-def aer2dca(az, el, srange, heading, deg=True):
+def aer2dca(az, el, srange, heading, 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, a, heading, deg=True):
+def dca2aer(dr, cr, above, heading, deg: bool = True):
     """
     Converts DCA (Downrange, Crossrange, Above) coordinates to AER (Azimuth, Elevation, Range).
     """
-    e, n, u = dca2enu(dr, cr, a, heading, deg=deg)
+    e, n, u = dca2enu(dr, cr, above, heading, deg=deg)
     return enu2aer(e, n, u, deg=deg)

src/pymap3d/ecef.py

@@ -525,6 +525,6 @@ def enu2ecef(
     """
 
     x0, y0, z0 = geodetic2ecef(lat0, lon0, h0, ell, deg=deg)
-    dx, dy, dz = enu2uvw(e1, n1, u1, lat0, lon0, deg=deg)
+    u, v, w = enu2uvw(e1, n1, u1, lat0, lon0, deg=deg)
 
-    return x0 + dx, y0 + dy, z0 + dz
+    return x0 + u, y0 + v, z0 + w

src/pymap3d/nvector.py

@@ -1,7 +1,11 @@
-import numpy as np
-import pymap3d as pm
+from __future__ import annotations
 
-def geodetic2nvector(lat, lon, ell=None, deg=True):
+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:
     """
     Convert geodetic coordinates (latitude, longitude) to an n-vector.
 
@@ -19,21 +23,21 @@ def geodetic2nvector(lat, lon, ell=None, deg=True):
         n1, n2, n3 : ndarray
             Components of the n-vector in the Earth-Centered Earth-Fixed (ECEF) coordinate system.
     """
-    lat, lon = np.atleast_1d(lat), np.atleast_1d(lon)
 
     if deg:
-        lat, lon = np.radians(lat), np.radians(lon)
+        lat, lon = radians(lat), radians(lon)
 
-    sin_lat, cos_lat = np.sin(lat), np.cos(lat)
-    sin_lon, cos_lon = np.sin(lon), np.cos(lon)
+    sin_lat, cos_lat = sin(lat), cos(lat)
+    sin_lon, cos_lon = sin(lon), cos(lon)
 
     n1 = cos_lat * cos_lon
     n2 = cos_lat * sin_lon
     n3 = sin_lat
 
     return n1, n2, n3
 
-def nvector2geodetic(n1, n2, n3, ell=None, deg=True):
+
+def nvector2geodetic(n1, n2, n3, deg=True) -> tuple:
     """
     Convert an n-vector back to geodetic coordinates (latitude, longitude).
 
@@ -49,18 +53,18 @@ def nvector2geodetic(n1, n2, n3, ell=None, deg=True):
         lat, lon : ndarray
             Geodetic latitude(s) and longitude(s).
     """
-    n1, n2, n3 = np.atleast_1d(n1), np.atleast_1d(n2), np.atleast_1d(n3)
 
     # Compute latitude and longitude from n-vector
-    lat = np.arcsin(n3)
-    lon = np.arctan2(n2, n1)
+    lat = asin(n3)
+    lon = atan2(n2, n1)
 
     if deg:
-        lat, lon = np.degrees(lat), np.degrees(lon)
+        lat, lon = degrees(lat), degrees(lon)
 
     return lat, lon
 
-def ecef2nvector(x, y, z, ell=None, deg=True):
+
+def ecef2nvector(x, y, z, ell: Ellipsoid | None = None, deg: bool = True):
     """
     Convert ECEF coordinates to an n-vector.
 
@@ -76,10 +80,12 @@ def ecef2nvector(x, y, z, ell=None, deg=True):
         n1, n2, n3 : ndarray
             Components of the n-vector in the Earth-Centered Earth-Fixed (ECEF) coordinate system.
     """
-    lat, lon, _ = pm.ecef2geodetic(x, y, z, ell=ell, deg=deg)
-    return geodetic2nvector(lat, lon, ell=ell, deg=deg)
 
-def nvector2ecef(n1, n2, n3, alt=0, ell=None, deg=True):
+    lat, lon, _ = ecef2geodetic(x, y, z, ell=ell, deg=deg)
+    return geodetic2nvector(lat, lon, deg=deg)
+
+
+def nvector2ecef(n1, n2, n3, alt=0, ell: Ellipsoid | None = None, deg: bool = True):
     """
     Convert an n-vector to ECEF coordinates.
 
@@ -97,5 +103,5 @@ def nvector2ecef(n1, n2, n3, alt=0, ell=None, deg=True):
         x, y, z : ndarray
             ECEF coordinates in meters.
     """
-    lat, lon = nvector2geodetic(n1, n2, n3, ell=ell, deg=deg)
-    return pm.geodetic2ecef(lat, lon, alt, ell=ell, deg=deg)
+    lat, lon = nvector2geodetic(n1, n2, n3, deg=deg)
+    return geodetic2ecef(lat, lon, alt, ell=ell, deg=deg)

src/pymap3d/tests/test_dca.py

@@ -0,0 +1,62 @@
+import pytest
+
+import pymap3d as pm
+
+
+def get_ellipsoid_params():
+    ell = pm.Ellipsoid.from_name("wgs84")
+    return ell.semimajor_axis, ell.semiminor_axis
+
+
+A, B = get_ellipsoid_params()
+
+
+@pytest.mark.parametrize(
+    "enu,dca,heading",
+    [
+        ((0, 0, 0), (0, 0, 0), 15),
+        ((-7.0710678118654755, 12.24744871391589, 1000), (10, 10, 1000), 15),
+        ((-2.455756079379457, 13.927284806400378, 1000), (10, 10, 1000), 35),
+    ],
+)
+def test_enu_dca(enu, dca, heading):
+
+    assert pm.dca2enu(*dca, heading) == pytest.approx(enu)
+    assert pm.enu2dca(*enu, 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)
+
+
+@pytest.mark.parametrize(
+    "ecef,dca,heading",
+    [
+        ((6027079.293014112, 1614951.0292814733, 1317408.7685803245), (0, 0, 0), 15),
+        ((6028023.481548891, 1615196.7033287943, 1317628.660083717), (10, 10, 1000), 15),
+    ],
+)
+def test_ecef_dca(ecef, dca, heading):
+    lat0, lon0, h0 = 12.0, 15.0, 30.0
+
+    assert pm.dca2ecef(*dca, lat0, lon0, h0, heading) == pytest.approx(ecef)
+    assert pm.ecef2dca(*ecef, lat0, lon0, h0, heading) == pytest.approx(dca, rel=1e-9)
+
+
+def test_geodetic_dca():
+    lat0, lon0, h0 = 12.0, 15.0, 30.0
+    heading = 15.0
+
+    lat, lon, h = 12.1, 15.1, 30.1
+    dca = pm.geodetic2dca(lat, lon, h, lat0, lon0, h0, heading)
+
+    assert pm.dca2geodetic(*dca, lat0, lon0, h0, heading) == pytest.approx((lat, lon, h))
+
+
+def test_aer_dca():
+    heading = 15.0
+
+    az, el, r = 10.0, 20.0, 1000.0
+    dca = pm.aer2dca(az, el, r, heading)
+
+    assert pm.dca2aer(*dca, heading) == pytest.approx((az, el, r))

src/pymap3d/tests/test_geodetic.py

@@ -70,9 +70,12 @@ def test_scalar_geodetic2ecef(lla):
     lla1 = pm.ecef2geodetic(*xyz)
 
     try:
-        np.testing.assert_allclose(lla1, lla, rtol=1e-4)
+        lla1 = np.array(lla1)
+        lla = np.array(lla)
     except NameError:
-        assert lla1 == approx(lla, rel=1e-4)
+        pass
+
+    assert lla1 == approx(lla, rel=1e-4)
 
     if scalar:
         assert all(isinstance(n, float) for n in xyz)
@@ -107,9 +110,12 @@ def test_scalar_ecef2geodetic(xyz):
     xyz1 = pm.geodetic2ecef(*lla)
 
     try:
-        np.testing.assert_allclose(xyz1, xyz, rtol=1e-4)
+        xyz1 = np.array(xyz1)
+        xyz = np.array(xyz)
     except NameError:
-        assert xyz1 == approx(xyz, rel=1e-4)
+        pass
+
+    assert xyz1 == approx(xyz, rel=1e-4)
 
     if scalar:
         assert all(isinstance(n, float) for n in xyz1)