parametrize test

test different input types

allow longitude to wrap

pandas.DataFrame

better testing and pandas

cleanup tests

don't squeeze unnecessarily

coverage

handle scalar if

meta

Author: scivision

README.md

@@ -27,7 +27,7 @@ Includes some relevant
 
 * Python ≥ 3.5 or PyPy3
 
-References to AstroPy are optional, algorithms from Vallado and Meeus are used if AstroPy is not present.
+References to AstroPy are *optional*, algorithms from Vallado and Meeus are used if AstroPy is not present.
 
 
 ## Install
@@ -128,3 +128,11 @@ As compared to [PyProj](https://github.com/jswhit/pyproj):
     PyMap3D handles points on or above the planet surface equally well,
     particularly important for airborne vehicles and remote sensing.
 
+### AstroPy.Units.Quantity
+
+At this time,
+[AstroPy.Units.Quantity](http://docs.astropy.org/en/stable/units/)
+is not supported.
+Let us know if this is of interest.
+Impacts on performance would have to be considered before making Quantity a first-class citizen.
+For now, you can workaround by passing in the `.value` of the variable.

pymap3d/ecef.py

@@ -6,7 +6,7 @@
 try:
     from math import tau  # py >= 3.6
 except ImportError:
-    tau = 2 * np.pi
+    tau = 2 * pi
 
 from .eci import eci2ecef
 
@@ -138,9 +138,6 @@ def geodetic2ecef(lat: float, lon: float, alt: float,
         if np.any((lat < -pi / 2) | (lat > pi / 2)):
             raise ValueError('-90 <= lat <= 90')
 
-        if np.any((lon < -pi) | (lon > tau)):
-            raise ValueError('-180 <= lat <= 360')
-
     # radius of curvature of the prime vertical section
     N = get_radius_normal(lat, ell)
     # Compute cartesian (geocentric) coordinates given  (curvilinear) geodetic
@@ -186,6 +183,10 @@ def ecef2geodetic(x: float, y: float, z: float,
     if ell is None:
         ell = Ellipsoid()
 
+    x = np.asarray(x)
+    y = np.asarray(y)
+    z = np.asarray(z)
+
     r = sqrt(x**2 + y**2 + z**2)
 
     E = sqrt(ell.a**2 - ell.b**2)
@@ -214,17 +215,19 @@ def ecef2geodetic(x: float, y: float, z: float,
     alt = hypot(z - ell.b * sin(Beta),
                 Q - ell.a * cos(Beta))
 
-    alt = np.atleast_1d(alt)
-
     # inside ellipsoid?
     with np.errstate(invalid='ignore'):
         inside = x**2 / ell.a**2 + y**2 / ell.a**2 + z**2 / ell.b**2 < 1
-    alt[inside] = -alt[inside]
+    if isinstance(inside, np.ndarray):
+        alt[inside] = -alt[inside]
+    elif inside:
+        alt = -alt
 
     if deg:
-        return degrees(lat), degrees(lon), alt.squeeze()[()]
-    else:
-        return lat, lon, alt.squeeze()[()]  # radians
+        lat = degrees(lat)
+        lon = degrees(lon)
+
+    return lat, lon, alt
 
 
 def ecef2enuv(u: float, v: float, w: float,

pymap3d/enu.py

@@ -41,25 +41,25 @@ def enu2aer(e: np.ndarray, n: np.ndarray, u: np.ndarray, deg: bool = True) -> Tu
     """
     # 1 millimeter precision for singularity
 
-    e = np.atleast_1d(e)
-    n = np.atleast_1d(n)
-    u = np.atleast_1d(u)
+    e = np.asarray(e)
+    n = np.asarray(n)
+    u = np.asarray(u)
 
     with np.errstate(invalid='ignore'):
         e[abs(e) < 1e-3] = 0.
         n[abs(n) < 1e-3] = 0.
         u[abs(u) < 1e-3] = 0.
 
-    r = hypot(e, n)
-    slantRange = hypot(r, u)
-    elev = arctan2(u, r)
-    az = arctan2(e, n) % tau
+        r = hypot(e, n)
+        slantRange = hypot(r, u)
+        elev = arctan2(u, r)
+        az = arctan2(e, n) % tau
 
     if deg:
         az = degrees(az)
         elev = degrees(elev)
 
-    return az[()].squeeze(), elev[()].squeeze(), slantRange[()].squeeze()
+    return az, elev, slantRange
 
 
 def aer2enu(az: float, el: float, srange: float, deg: bool = True) -> Tuple[float, float, float]:

pymap3d/vallado.py

@@ -63,8 +63,6 @@ def azel2radec(az_deg: float, el_deg: float,
         raise ValueError('need one observer and one or more  (az,el).')
     if ((lat < -90) | (lat > 90)).any():
         raise ValueError('-90 <= lat <= 90')
-    if ((lon < -180) | (lon > 360)).any():
-        raise ValueError('-180 <= lat <= 360')
 
     az = radians(az)
     el = radians(el)
@@ -130,8 +128,6 @@ def radec2azel(ra_deg: float, dec_deg: float,
         raise ValueError('need one observer and one or more  (az,el).')
     if ((lat < -90) | (lat > 90)).any():
         raise ValueError('-90 <= lat <= 90')
-    if ((lon < -180) | (lon > 360)).any():
-        raise ValueError('-180 <= lat <= 360')
 
     ra = radians(ra)
     dec = radians(dec)

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = pymap3d
-version = 1.7.14
+version = 1.7.15
 author = Michael Hirsch, Ph.D.
 author_email = [email protected]
 description = pure Python coordinate conversions, following convention of several popular Matlab routines.

tests/test_astropy.py

@@ -14,18 +14,16 @@
 eci0 = (-3.977913815668146e6, -2.582332196263046e6, 4.250818828152067e6)
 
 
-def test_sidereal():
+@pytest.mark.parametrize('time', [t0, [t0]], ids=('scalar', 'list'))
+def test_sidereal(time):
     pytest.importorskip('astropy')
     # http://www.jgiesen.de/astro/astroJS/siderealClock/
-    assert pmd.datetime2sidereal(t0, np.radians(lon), False) == approx(sra, rel=1e-5)
+    assert pmd.datetime2sidereal(time, np.radians(lon), False) == approx(sra, rel=1e-5)
 
-    assert pmd.datetime2sidereal([t0], np.radians(lon), False) == approx(sra, rel=1e-5)
 
-
-def test_sidereal_vallado():
-    assert pmd.datetime2sidereal(t0, np.radians(lon), True) == approx(sra, rel=1e-5)
-
-    assert pmd.datetime2sidereal([t0], np.radians(lon), True) == approx(sra, rel=1e-5)
+@pytest.mark.parametrize('time', [t0, [t0]], ids=('scalar', 'list'))
+def test_sidereal_vallado(time):
+    assert pmd.datetime2sidereal(time, np.radians(lon), True) == approx(sra, rel=1e-5)
 
 
 def test_anglesep():

tests/test_geodetic.py

@@ -23,6 +23,89 @@
 atol_dist = 1e-6  # 1 micrometer
 
 
+@pytest.mark.parametrize('lla',
+                         [(42, -82, 200),
+                          ([42], [-82], [200]),
+                          (np.array(42), np.array(-82), np.array(200)),
+                          (np.array([42]), np.array([-82]), np.array([200])),
+                          (np.atleast_3d(42), np.atleast_3d(-82), np.atleast_3d(200))],
+                         ids=('scalar', 'list', '0d', '1d', '3d'))
+def test_scalar_geodetic2ecef(lla):
+    """
+    verify we can handle the wide variety of input data type users might use
+    """
+    x0, y0, z0 = pm.geodetic2ecef(*lla)
+
+    assert (x0, y0, z0) == approx(xyz0)
+
+
+@pytest.mark.parametrize('xyz',
+                         [(xyz0[0], xyz0[1], xyz0[2]),
+                          ([xyz0[0]], [xyz0[1]], [xyz0[2]]),
+                          (np.array(xyz0[0]), np.array(xyz0[1]), np.array(xyz0[2])),
+                          (np.array([xyz0[0]]), np.array([xyz0[1]]), np.array([xyz0[2]])),
+                          (np.atleast_3d(xyz0[0]), np.atleast_3d(xyz0[1]), np.atleast_3d(xyz0[2]))],
+                         ids=('scalar', 'list', '0d', '1d', '3d'))
+def test_scalar_ecef2geodetic(xyz):
+    """
+    verify we can handle the wide variety of input data type users might use
+    """
+    lat, lon, alt = pm.ecef2geodetic(*xyz)
+
+    assert [lat, lon, alt] == approx(lla0, rel=1e-4)
+
+
+@pytest.mark.parametrize('xyz',
+                         [(0, E.a, 50),
+                          ([0], [E.a], [50]),
+                          (np.array(0), np.array(E.a), np.array(50)),
+                          (np.array([0]), np.array([E.a]), np.array([50])),
+                          (np.atleast_3d(0), np.atleast_3d(E.a), np.atleast_3d(50))],
+                         ids=('scalar', 'list', '0d', '1d', '3d'))
+def test_scalar_aer_enu(xyz):
+    """
+    verify we can handle the wide variety of input data type users might use
+    """
+    enu = pm.ecef2enu(*xyz, 0, 90, -100)
+
+    assert pm.enu2ecef(*enu, 0, 90, -100) == approx([0, E.a, 50])
+
+
+def test_xarray():
+    xarray = pytest.importorskip('xarray')
+    xr_lla = xarray.DataArray(list(lla0))
+
+    xyz = pm.geodetic2ecef(*xr_lla)
+
+    assert xyz == approx(xyz0)
+    assert isinstance(xyz[0], xarray.DataArray)
+# %%
+    xr_xyz = xarray.DataArray(list(xyz0))
+
+    lla = pm.ecef2geodetic(*xr_xyz)
+
+    assert lla == approx(lla0)
+    assert isinstance(lla[0], float)  # xarrayness is lost, possibly expensive to keep due to isinstance()
+
+
+def test_pandas():
+    pandas = pytest.importorskip('pandas')
+    pd_lla = pandas.Series(lla0)
+
+    xyz = pm.geodetic2ecef(*pd_lla)
+
+    assert xyz == approx(xyz0)
+    assert isinstance(xyz[0], float)  # series degenerates to scalars by pandas itself
+# %% dataframe degenerates to series
+    pd_lla = pandas.DataFrame([[*lla0], [*lla0]], columns=['lat', 'lon', 'alt_m'])
+    xyz = pm.geodetic2ecef(pd_lla['lat'], pd_lla['lon'], pd_lla['alt_m'])
+
+    assert xyz[0].values == approx(xyz0[0])
+    assert xyz[1].values == approx(xyz0[1])
+    assert xyz[2].values == approx(xyz0[2])
+    assert isinstance(xyz[0], pandas.Series)
+
+
 def test_ecef():
     xyz = pm.geodetic2ecef(*lla0)
 
@@ -32,9 +115,6 @@ def test_ecef():
     with pytest.raises(ValueError):
         pm.geodetic2ecef(-100, lla0[1], lla0[2])
 
-    with pytest.raises(ValueError):
-        pm.geodetic2ecef(lla0[0], -200, lla0[2])
-
     assert pm.ecef2geodetic(*xyz) == approx(lla0)
     assert pm.ecef2geodetic(*xyz, deg=False) == approx(rlla0)
 
@@ -93,4 +173,4 @@ def test_somenan():
 
 
 if __name__ == '__main__':
-    pytest.main([__file__])
+    pytest.main(['-x', __file__])