Merge branch 'ryanpavlick-main'

Author: scivision

.github/contributors.md

@@ -2,7 +2,7 @@ Thanks to those who contributed code and ideas, including:
 
 ```
 @aldebaran1 (robustness)
-@rpavlick (multiple features + functions)
+@ryanpavlick (.rsphere, .rcurve, .latitude, .lox, .los, .dca, and more)
 @cchuravy (Ellipsoid parameters)
 @jprMesh  (more conversion functions)
 @Fil (docs)

src/pymap3d/__init__.py

@@ -32,6 +32,19 @@
 __version__ = "3.1.2"
 
 from .aer import aer2ecef, aer2geodetic, ecef2aer, geodetic2aer
+from .dca import (
+    enu2dca,
+    dca2enu,
+    dca2ned,
+    ned2dca,
+    ecef2dca,
+    dca2ecef,
+    geodetic2dca,
+    dca2geodetic,
+    aer2dca,
+    dca2aer,
+)
+
 from .ecef import (
     ecef2enu,
     ecef2enuv,
@@ -75,6 +88,8 @@
     geoc2geod,
 )
 
+from .nvector import geodetic2nvector, nvector2geodetic, ecef2nvector, nvector2ecef
+
 from .rcurve import parallel, meridian, transverse, geocentric_radius
 
 __all__ = [
@@ -129,8 +144,23 @@
     "authalic2geodetic",
     "geod2geoc",
     "geoc2geod",
+    "nvector2geodetic",
+    "geodetic2nvector",
+    "ecef2nvector",
+    "nvector2ecef",
+    "enu2dca",
+    "dca2enu",
+    "dca2ned",
+    "ned2dca",
+    "ecef2dca",
+    "dca2ecef",
+    "geodetic2dca",
+    "dca2geodetic",
+    "aer2dca",
+    "dca2aer",
 ]
 
+
 from .aer import aer2eci, eci2aer
 from .azelradec import azel2radec, radec2azel
 from .eci import ecef2eci, eci2ecef

src/pymap3d/dca.py

@@ -0,0 +1,130 @@
+"""
+Transforms involving DCA (Downrange, Crossrange, Above)
+
+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). 
+
+It also includes transformations to/from AER (Azimuth, Elevation, Range).
+
+Functions:
+----------
+- enu2dca: Convert ENU to DCA coordinates.
+- dca2enu: Convert DCA to ENU coordinates.
+- dca2ned: Convert DCA to NED coordinates.
+- ned2dca: Convert NED to DCA coordinates.
+- ecef2dca: Convert ECEF to DCA coordinates.
+- dca2ecef: Convert DCA to ECEF coordinates.
+- geodetic2dca: Convert geodetic to DCA coordinates.
+- dca2geodetic: Convert DCA to geodetic coordinates.
+- aer2dca: Convert AER to DCA coordinates.
+- dca2aer: Convert DCA to AER coordinates.
+"""
+
+from .mathfun import sin, cos, radians
+from .ecef import ecef2enu, enu2ecef
+from .enu import geodetic2enu, enu2geodetic, aer2enu, enu2aer
+from .ellipsoid import Ellipsoid
+
+__all__ = [
+    "enu2dca",
+    "dca2enu",
+    "dca2ned",
+    "ned2dca",
+    "ecef2dca",
+    "dca2ecef",
+    "geodetic2dca",
+    "dca2geodetic",
+    "aer2dca",
+    "dca2aer",
+]
+
+ELL = Ellipsoid.from_name("wgs84")  # Default reference ellipsoid (WGS84)
+
+
+def enu2dca(e, n, u, heading, deg=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
+
+
+def dca2enu(dr, cr, a, heading, deg=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
+
+
+def dca2ned(dr, cr, a, heading, deg=True):
+    """
+    Converts DCA (Downrange, Crossrange, Above) coordinates to NED (North, East, Down).
+    """
+    e, n, u = dca2enu(dr, cr, a, heading, deg=deg)
+    return n, e, -u
+
+
+def ned2dca(n, e, d, heading, deg=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
+
+
+def ecef2dca(x, y, z, lat0, lon0, h0, heading, ell=ELL, deg=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):
+    """
+    Converts DCA (Downrange, Crossrange, Above) coordinates to ECEF (Earth-Centered, Earth-Fixed) coordinates.
+    """
+    e, n, u = dca2enu(dr, cr, a, 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):
+    """
+    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):
+    """
+    Converts DCA (Downrange, Crossrange, Above) coordinates to geodetic coordinates (latitude, longitude, altitude).
+    """
+    e, n, u = dca2enu(dr, cr, a, heading, deg=deg)
+    return enu2geodetic(e, n, u, lat0, lon0, h0, ell, deg=deg)
+
+
+def aer2dca(az, el, srange, heading, deg=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):
+    """
+    Converts DCA (Downrange, Crossrange, Above) coordinates to AER (Azimuth, Elevation, Range).
+    """
+    e, n, u = dca2enu(dr, cr, a, heading, deg=deg)
+    return enu2aer(e, n, u, deg=deg)

src/pymap3d/nvector.py

@@ -0,0 +1,101 @@
+import numpy as np
+import pymap3d as pm
+
+def geodetic2nvector(lat, lon, ell=None, deg=True):
+    """
+    Convert geodetic coordinates (latitude, longitude) to an n-vector.
+
+    Parameters:
+        lat : float or array-like
+            Geodetic latitude(s).
+        lon : float or array-like
+            Geodetic longitude(s).
+        ell : str or tuple, optional
+            Reference ellipsoid (default is None, which uses WGS84).
+        deg : bool, optional
+            If True (default), inputs are in degrees. If False, use radians.
+
+    Returns:
+        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)
+
+    sin_lat, cos_lat = np.sin(lat), np.cos(lat)
+    sin_lon, cos_lon = np.sin(lon), np.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):
+    """
+    Convert an n-vector back to geodetic coordinates (latitude, longitude).
+
+    Parameters:
+        n1, n2, n3 : float or array-like
+            Components of the n-vector in the Earth-Centered Earth-Fixed (ECEF) coordinate system.
+        ell : str or tuple, optional
+            Reference ellipsoid (default is None, which uses WGS84).
+        deg : bool, optional
+            If True (default), returns latitude and longitude in degrees. If False, in radians.
+
+    Returns:
+        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)
+
+    if deg:
+        lat, lon = np.degrees(lat), np.degrees(lon)
+
+    return lat, lon
+
+def ecef2nvector(x, y, z, ell=None, deg=True):
+    """
+    Convert ECEF coordinates to an n-vector.
+
+    Parameters:
+        x, y, z : float or array-like
+            ECEF coordinates in meters.
+        ell : str or tuple, optional
+            Reference ellipsoid (default is None, which uses WGS84).
+        deg : bool, optional
+            If True (default), geodetic2nvector() inputs are in degrees. If False, in radians.
+
+    Returns:
+        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):
+    """
+    Convert an n-vector to ECEF coordinates.
+
+    Parameters:
+        n1, n2, n3 : float or array-like
+            Components of the n-vector in the Earth-Centered Earth-Fixed (ECEF) coordinate system.
+        alt : float or array-like, optional
+            Altitude in meters (default is 0).
+        ell : str or tuple, optional
+            Reference ellipsoid (default is None, which uses WGS84).
+        deg : bool, optional
+            If True (default), nvector2geodetic() outputs are in degrees. If False, in radians.
+
+    Returns:
+        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)