finish adding new functions, apply black code style

Author: scivision

examples/angle_distance.py

@@ -6,19 +6,19 @@
 
 def main():
     p = ArgumentParser(description="angular distance between two sky points")
-    p.add_argument('r0', help='right ascension: first point [deg]', type=float)
-    p.add_argument('d0', help='declination: first point [deg]', type=float)
-    p.add_argument('r1', help='right ascension: 2nd point [deg]', type=float)
-    p.add_argument('d1', help='declination: 2nd point [degrees]', type=float)
+    p.add_argument("r0", help="right ascension: first point [deg]", type=float)
+    p.add_argument("d0", help="declination: first point [deg]", type=float)
+    p.add_argument("r1", help="right ascension: 2nd point [deg]", type=float)
+    p.add_argument("d1", help="declination: 2nd point [degrees]", type=float)
     a = p.parse_args()
 
     dist_deg = anglesep_meeus(a.r0, a.d0, a.r1, a.d1)
     dist_deg_astropy = anglesep(a.r0, a.d0, a.r1, a.d1)
 
-    print('{:.6f} deg sep'.format(dist_deg))
+    print("{:.6f} deg sep".format(dist_deg))
 
     assert dist_deg == approx(dist_deg_astropy)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

examples/azel2radec.py

@@ -9,18 +9,17 @@
 
 
 def main():
-    p = ArgumentParser(description="convert azimuth and elevation to "
-                       "right ascension and declination")
-    p.add_argument('azimuth', help='azimuth [deg]', type=float)
-    p.add_argument('elevation', help='elevation [deg]', type=float)
-    p.add_argument('lat', help='WGS84 obs. lat [deg]', type=float)
-    p.add_argument('lon', help='WGS84 obs. lon [deg]', type=float)
-    p.add_argument('time', help='obs. time YYYY-mm-ddTHH:MM:SSZ')
+    p = ArgumentParser(description="convert azimuth and elevation to " "right ascension and declination")
+    p.add_argument("azimuth", help="azimuth [deg]", type=float)
+    p.add_argument("elevation", help="elevation [deg]", type=float)
+    p.add_argument("lat", help="WGS84 obs. lat [deg]", type=float)
+    p.add_argument("lon", help="WGS84 obs. lon [deg]", type=float)
+    p.add_argument("time", help="obs. time YYYY-mm-ddTHH:MM:SSZ")
     P = p.parse_args()
 
     ra, dec = azel2radec(P.azimuth, P.elevation, P.lat, P.lon, P.time)
 
-    print('ra [deg] ', ra, ' dec [deg] ', dec)
+    print("ra [deg] ", ra, " dec [deg] ", dec)
 
 
 if __name__ == "__main__":  # pragma: no cover

examples/radec2azel.py

@@ -9,21 +9,18 @@
 
 
 def main():
-    p = ArgumentParser(description="RightAscension,Declination =>"
-                                   "Azimuth,Elevation")
-    p.add_argument('ra', help='right ascension [degrees]', type=float)
-    p.add_argument('dec', help='declination [degrees]', type=float)
-    p.add_argument('lat', help='WGS84 latitude of observer [degrees]',
-                   type=float)
-    p.add_argument('lon', help='WGS84 latitude of observer [degrees]',
-                   type=float)
-    p.add_argument('time', help='UTC time of observation YYYY-mm-ddTHH:MM:SSZ')
+    p = ArgumentParser(description="RightAscension,Declination =>" "Azimuth,Elevation")
+    p.add_argument("ra", help="right ascension [degrees]", type=float)
+    p.add_argument("dec", help="declination [degrees]", type=float)
+    p.add_argument("lat", help="WGS84 latitude of observer [degrees]", type=float)
+    p.add_argument("lon", help="WGS84 latitude of observer [degrees]", type=float)
+    p.add_argument("time", help="UTC time of observation YYYY-mm-ddTHH:MM:SSZ")
     P = p.parse_args()
 
     az_deg, el_deg = radec2azel(P.ra, P.dec, P.lat, P.lon, P.time)
-    print('azimuth: [deg]', az_deg)
-    print('elevation [deg]:', el_deg)
+    print("azimuth: [deg]", az_deg)
+    print("elevation [deg]:", el_deg)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

examples/vdist.py

@@ -4,17 +4,17 @@
 
 
 def main():
-    p = ArgumentParser(description='vdist distance between WGS-84 coordinates')
-    p.add_argument('lat1', help='latitude1 WGS-84 [degrees]', type=float)
-    p.add_argument('lon1', help='longitude1 WGS-84 [degrees]', type=float)
-    p.add_argument('lat2', help='latitude2 WGS-84 [degrees]', type=float)
-    p.add_argument('lon2', help='longitude2 WGS-84 [degrees]', type=float)
+    p = ArgumentParser(description="vdist distance between WGS-84 coordinates")
+    p.add_argument("lat1", help="latitude1 WGS-84 [degrees]", type=float)
+    p.add_argument("lon1", help="longitude1 WGS-84 [degrees]", type=float)
+    p.add_argument("lat2", help="latitude2 WGS-84 [degrees]", type=float)
+    p.add_argument("lon2", help="longitude2 WGS-84 [degrees]", type=float)
     P = p.parse_args()
 
     dist_m = vdist(P.lat1, P.lon1, P.lat2, P.lon2)
 
-    print('{:.3f} {:.3f} {:.3f}'.format(*dist_m))
+    print("{:.3f} {:.3f} {:.3f}".format(*dist_m))
 
 
-if __name__ == '__main__':  # pragma: no cover
+if __name__ == "__main__":  # pragma: no cover
     main()

examples/vdist_poi.py

@@ -17,14 +17,11 @@
 from pymap3d.vincenty import vdist
 
 
-URL = 'https://maps.googleapis.com/maps/api/place/nearbysearch/json?'
+URL = "https://maps.googleapis.com/maps/api/place/nearbysearch/json?"
 
 
 @functools.lru_cache()
-def get_place_coords(place_type: str,
-                     latitude: float, longitude: float,
-                     search_radius_km: int,
-                     keyfn: Path) -> pandas.DataFrame:
+def get_place_coords(place_type: str, latitude: float, longitude: float, search_radius_km: int, keyfn: Path) -> pandas.DataFrame:
     """
     Get places using Google Maps Places API
     Requires you to have a Google Cloud account with API key.
@@ -33,37 +30,36 @@ def get_place_coords(place_type: str,
     keyfn = Path(keyfn).expanduser()
     key = keyfn.read_text()
 
-    stub = URL + 'location={},{}'.format(latitude, longitude)
+    stub = URL + "location={},{}".format(latitude, longitude)
 
-    stub += '&radius={}'.format(search_radius_km * 1000)
+    stub += "&radius={}".format(search_radius_km * 1000)
 
-    stub += '&types={}'.format(place_type)
+    stub += "&types={}".format(place_type)
 
-    stub += '&key={}'.format(key)
+    stub += "&key={}".format(key)
 
     r = requests.get(stub)
     r.raise_for_status()
 
-    place_json = r.json()['results']
+    place_json = r.json()["results"]
 
-    places = pandas.DataFrame(index=[p['name'] for p in place_json],
-                              columns=['latitude', 'longitude', 'distance_km', 'vicinity'])
-    places['latitude'] = [p['geometry']['location']['lat'] for p in place_json]
-    places['longitude'] = [p['geometry']['location']['lng'] for p in place_json]
-    places['vicinity'] = [p['vicinity'] for p in place_json]
+    places = pandas.DataFrame(index=[p["name"] for p in place_json], columns=["latitude", "longitude", "distance_km", "vicinity"])
+    places["latitude"] = [p["geometry"]["location"]["lat"] for p in place_json]
+    places["longitude"] = [p["geometry"]["location"]["lng"] for p in place_json]
+    places["vicinity"] = [p["vicinity"] for p in place_json]
 
     return places
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     p = ArgumentParser()
-    p.add_argument('place_type', help='Place type to search: https://developers.google.com/places/supported_types')
-    p.add_argument('searchloc', help='initial latituude, longitude to search from', nargs=2, type=float)
-    p.add_argument('radius', help='search radius (kilometers)', type=int)
-    p.add_argument('refloc', help='reference location (lat, lon)', nargs=2, type=float)
-    p.add_argument('-k', '--keyfn', help='Google Places API key file', default='~/googlemaps.key')
+    p.add_argument("place_type", help="Place type to search: https://developers.google.com/places/supported_types")
+    p.add_argument("searchloc", help="initial latituude, longitude to search from", nargs=2, type=float)
+    p.add_argument("radius", help="search radius (kilometers)", type=int)
+    p.add_argument("refloc", help="reference location (lat, lon)", nargs=2, type=float)
+    p.add_argument("-k", "--keyfn", help="Google Places API key file", default="~/googlemaps.key")
     a = p.parse_args()
 
     place_coords = get_place_coords(a.place_type, *a.searchloc, a.radius, a.keyfn)
 
-    place_coords['distance_km'] = vdist(place_coords['latitude'], place_coords['longitude'], *a.refloc)[0] / 1e3
+    place_coords["distance_km"] = vdist(place_coords["latitude"], place_coords["longitude"], *a.refloc)[0] / 1e3

examples/vreckon.py

@@ -4,18 +4,18 @@
 
 
 def main():
-    p = ArgumentParser(description='Given starting latitude, longitude: find final lat,lon for distance and azimuth')
-    p.add_argument('lat', help='latitude WGS-84 [degrees]', type=float)
-    p.add_argument('lon', help='longitude WGS-84 [degrees]', type=float)
-    p.add_argument('range', help='range from start point [meters]', type=float)
-    p.add_argument('azimuth', help='clockwise from north: azimuth to start [degrees]', type=float)
+    p = ArgumentParser(description="Given starting latitude, longitude: find final lat,lon for distance and azimuth")
+    p.add_argument("lat", help="latitude WGS-84 [degrees]", type=float)
+    p.add_argument("lon", help="longitude WGS-84 [degrees]", type=float)
+    p.add_argument("range", help="range from start point [meters]", type=float)
+    p.add_argument("azimuth", help="clockwise from north: azimuth to start [degrees]", type=float)
     P = p.parse_args()
 
     lat2, lon2, a21 = vreckon(P.lat, P.lon, P.range, P.azimuth)
 
-    print('{:.4f} {:.4f}'.format(lat2, lon2))
-    print('{:.1f}'.format(a21))
+    print("{:.4f} {:.4f}".format(lat2, lon2))
+    print("{:.1f}".format(a21))
 
 
-if __name__ == '__main__':  # pragma: no cover
+if __name__ == "__main__":  # pragma: no cover
     main()

pymap3d/__init__.py

@@ -52,8 +52,16 @@
     parametric2geodetic,
 )
 from .rcurve import rcurve_parallel, rcurve_meridian, rcurve_transverse
-from .rsphere import rsphere_eqavol, rsphere_authalic, rsphere_rectifying, rsphere_euler, rsphere_curve, rsphere_triaxial, rsphere_biaxial
-from .lox import isometric, meridian_dist, loxodrome_inverse
+from .rsphere import (
+    rsphere_eqavol,
+    rsphere_authalic,
+    rsphere_rectifying,
+    rsphere_euler,
+    rsphere_curve,
+    rsphere_triaxial,
+    rsphere_biaxial,
+)
+from .lox import meridian_arc, meridian_dist, loxodrome_inverse, loxodrome_direct, departure, meanm
 from .los import lookAtSpheroid
 from .timeconv import str2dt
 

pymap3d/aer.py

@@ -5,17 +5,18 @@
 from .ecef import ecef2enu, geodetic2ecef, ecef2geodetic, enu2uvw
 from .enu import geodetic2enu, aer2enu, enu2aer
 from .ellipsoid import Ellipsoid
+
 try:
     from .eci import eci2ecef, ecef2eci
 except ImportError:
     eci2ecef = ecef2eci = None
 
-__all__ = ['aer2ecef', 'ecef2aer', 'geodetic2aer', 'aer2geodetic']
+__all__ = ["aer2ecef", "ecef2aer", "geodetic2aer", "aer2geodetic"]
 
 
-def ecef2aer(x: float, y: float, z: float,
-             lat0: float, lon0: float, h0: float,
-             ell: Ellipsoid = None, deg: bool = True) -> Tuple[float, float, float]:
+def ecef2aer(
+    x: float, y: float, z: float, lat0: float, lon0: float, h0: float, ell: Ellipsoid = None, deg: bool = True
+) -> Tuple[float, float, float]:
     """
     gives azimuth, elevation and slant range from an Observer to a Point with ECEF coordinates.
 
@@ -55,9 +56,9 @@ def ecef2aer(x: float, y: float, z: float,
     return enu2aer(xEast, yNorth, zUp, deg=deg)
 
 
-def geodetic2aer(lat: float, lon: float, h: float,
-                 lat0: float, lon0: float, h0: float,
-                 ell: Ellipsoid = None, deg: bool = True) -> Tuple[float, float, float]:
+def geodetic2aer(
+    lat: float, lon: float, h: float, lat0: float, lon0: float, h0: float, ell: Ellipsoid = None, deg: bool = True
+) -> Tuple[float, float, float]:
     """
     gives azimuth, elevation and slant range from an Observer to a Point with geodetic coordinates.
 
@@ -96,10 +97,9 @@ def geodetic2aer(lat: float, lon: float, h: float,
     return enu2aer(e, n, u, deg=deg)
 
 
-def aer2geodetic(az: float, el: float, srange: float,
-                 lat0: float, lon0: float, h0: float,
-                 ell: Ellipsoid = None,
-                 deg: bool = True) -> Tuple[float, float, float]:
+def aer2geodetic(
+    az: float, el: float, srange: float, lat0: float, lon0: float, h0: float, ell: Ellipsoid = None, deg: bool = True
+) -> Tuple[float, float, float]:
     """
     gives geodetic coordinates of a point with az, el, range
     from an observer at lat0, lon0, h0
@@ -140,10 +140,9 @@ def aer2geodetic(az: float, el: float, srange: float,
     return ecef2geodetic(x, y, z, ell=ell, deg=deg)
 
 
-def eci2aer(x: float, y: float, z: float,
-            lat0: float, lon0: float, h0: float,
-            t: datetime,
-            useastropy: bool = True) -> Tuple[float, float, float]:
+def eci2aer(
+    x: float, y: float, z: float, lat0: float, lon0: float, h0: float, t: datetime, useastropy: bool = True
+) -> Tuple[float, float, float]:
     """
     takes ECI coordinates of point and gives az, el, slant range from Observer
 
@@ -183,10 +182,18 @@ def eci2aer(x: float, y: float, z: float,
     return ecef2aer(xecef, yecef, zecef, lat0, lon0, h0)
 
 
-def aer2eci(az: float, el: float, srange: float,
-            lat0: float, lon0: float, h0: float, t: datetime,
-            ell=None, deg: bool = True,
-            useastropy: bool = True) -> Tuple[float, float, float]:
+def aer2eci(
+    az: float,
+    el: float,
+    srange: float,
+    lat0: float,
+    lon0: float,
+    h0: float,
+    t: datetime,
+    ell=None,
+    deg: bool = True,
+    useastropy: bool = True,
+) -> Tuple[float, float, float]:
     """
     gives ECI of a point from an observer at az, el, slant range
 
@@ -231,9 +238,9 @@ def aer2eci(az: float, el: float, srange: float,
     return ecef2eci(x, y, z, t, useastropy=useastropy)
 
 
-def aer2ecef(az: float, el: float, srange: float,
-             lat0: float, lon0: float, alt0: float,
-             ell: Ellipsoid = None, deg: bool = True) -> Tuple[float, float, float]:
+def aer2ecef(
+    az: float, el: float, srange: float, lat0: float, lon0: float, alt0: float, ell: Ellipsoid = None, deg: bool = True
+) -> Tuple[float, float, float]:
     """
     converts target azimuth, elevation, range from observer at lat0,lon0,alt0 to ECEF coordinates.
 

pymap3d/azelradec.py

@@ -5,6 +5,7 @@
 from datetime import datetime
 from .vallado import azel2radec as vazel2radec, radec2azel as vradec2azel
 from .timeconv import str2dt  # astropy can't handle xarray times (yet)
+
 try:
     from astropy.time import Time
     from astropy import units as u
@@ -13,9 +14,9 @@
     Time = None
 
 
-def azel2radec(az_deg: float, el_deg: float,
-               lat_deg: float, lon_deg: float,
-               time: datetime, usevallado: bool = False) -> Tuple[float, float]:
+def azel2radec(
+    az_deg: float, el_deg: float, lat_deg: float, lon_deg: float, time: datetime, usevallado: bool = False
+) -> Tuple[float, float]:
     """
     viewing angle (az, el) to sky coordinates (ra, dec)
 
@@ -47,17 +48,16 @@ def azel2radec(az_deg: float, el_deg: float,
 
     obs = EarthLocation(lat=lat_deg * u.deg, lon=lon_deg * u.deg)
 
-    direc = AltAz(location=obs, obstime=Time(str2dt(time)),
-                  az=az_deg * u.deg, alt=el_deg * u.deg)
+    direc = AltAz(location=obs, obstime=Time(str2dt(time)), az=az_deg * u.deg, alt=el_deg * u.deg)
 
     sky = SkyCoord(direc.transform_to(ICRS()))
 
     return sky.ra.deg, sky.dec.deg
 
 
-def radec2azel(ra_deg: float, dec_deg: float,
-               lat_deg: float, lon_deg: float,
-               time: datetime, usevallado: bool = False) -> Tuple[float, float]:
+def radec2azel(
+    ra_deg: float, dec_deg: float, lat_deg: float, lon_deg: float, time: datetime, usevallado: bool = False
+) -> Tuple[float, float]:
     """
     sky coordinates (ra, dec) to viewing angle (az, el)
 
@@ -87,12 +87,9 @@ def radec2azel(ra_deg: float, dec_deg: float,
     if usevallado or Time is None:
         return vradec2azel(ra_deg, dec_deg, lat_deg, lon_deg, time)
 
-    obs = EarthLocation(lat=lat_deg * u.deg,
-                        lon=lon_deg * u.deg)
+    obs = EarthLocation(lat=lat_deg * u.deg, lon=lon_deg * u.deg)
 
-    points = SkyCoord(Angle(ra_deg, unit=u.deg),
-                      Angle(dec_deg, unit=u.deg),
-                      equinox='J2000.0')
+    points = SkyCoord(Angle(ra_deg, unit=u.deg), Angle(dec_deg, unit=u.deg), equinox="J2000.0")
 
     altaz = points.transform_to(AltAz(location=obs, obstime=Time(str2dt(time))))