def test_vdist(): lat1, lon1, a21 = vreckon(*ll0, sr[0], az[0]) assert vdist(*ll0, lat1, lon1) == approx((sr[0], az[0], a21)) # lat, lon vectors asr, aaz, aa21 = vdist(*ll0, lat2, lon2) assert np.all(sr[0] == approx(asr)) # for older pytest assert aaz == approx(az)
def test_vdist(): pytest.importorskip('pytest', minversion='3.5') lat1, lon1, a21 = vreckon(*ll0, sr[0], az[0]) assert vdist(*ll0, lat1, lon1) == approx((sr[0], az[0], a21)) # lat, lon vectors asr, aaz, aa21 = vdist(*ll0, lat2, lon2) assert np.all(sr[0] == approx(asr)) # for older pytest assert aaz == approx(az)
def test_unit(lat, lon, lat1, lon1, srange, az): dist, az1 = vincenty.vdist(lat, lon, lat1, lon1) assert dist == approx(srange, rel=0.005) assert az1 == approx(az) assert isinstance(dist, float) assert isinstance(az1, float)
def test_vector(): pytest.importorskip("numpy") asr, aaz = vincenty.vdist(10, 20, [10.02137267, 10.01917819], [20.0168471, 20.0193493]) assert 3e3 == approx(asr) assert aaz == approx([38, 45])
def test_identity(lat, lon, slantrange, az): lat1, lon1 = vincenty.vreckon(lat, lon, slantrange, az) dist, az1 = vincenty.vdist(lat, lon, lat1, lon1) assert dist == approx(slantrange) assert az1 == approx(az)
def bench_vdist(N: int) -> float: lat = np.random.random(N) lon = np.random.random(N) tic = time.monotonic() asr, aaz = vdist(ll0[0], ll0[1], lat, lon) return time.monotonic() - tic
def bench_vdist(N: int) -> float: lat = np.random.random(N) lon = np.random.random(N) tic = time() asr, aaz, aa21 = vdist(*ll0, lat, lon) return time() - tic
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 = p.parse_args() dist_m = vdist(P.lat1, P.lon1, P.lat2, P.lon2) print('distance between WGS-84 points: {} m'.format(dist_m))
def distance_matrix(station_locations): # figure out good ordering for the stations (rows) a = station_locations[:, None, :] * np.ones((1, station_locations.shape[0], station_locations.shape[1])) locs = np.reshape(np.concatenate((a, np.transpose(a, [1, 0, 2])), axis=2), (-1, 4)).astype(float) d, a1, a2 = vdist(locs[:, 1], locs[:, 0], locs[:, 3], locs[:, 2]) dists = d.reshape((station_locations.shape[0], station_locations.shape[0])) dists[np.isnan(dists)] = 0 return dists
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 = p.parse_args() dist_m = vdist(P.lat1, P.lon1, P.lat2, P.lon2) print('{:.3f} {:.3f} {:.3f}'.format(*dist_m))
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 = p.parse_args() dist_m = vdist(P.lat1, P.lon1, P.lat2, P.lon2) print("{:.3f} {:.3f} {:.3f}".format(*dist_m))
def find_closest_stations(mag_loc, loc): # calculate distance between 'loc' and the location in mag_data lat1 = mag_loc[:, 1] lon1 = mag_loc[:, 0] * 360 / 24 lat2 = np.ones_like(lat1) * loc[1] lon2 = np.ones_like(lon1) * loc[0] * 360 / 24 s, a12, a21 = vdist(lat1, lon1, lat2, lon2) # if for some reason everything is NaNs, exit if np.all(np.isnan(s)): return # if there is a single NaN in the time series for a station, the np.mean will cause that entry in 'distances' to # be NaN, here I make all NaNs equal to a maximum value, therefor disqualifying the station from being used. s[np.isnan(s)] = np.nanmax(s) sort_idx = np.argsort(s) # return the indexes of the stations, sorted by distance return sort_idx
def drawmap(dat, callsign, call2, b): callsign = callsign.upper() call2 = [c.upper() for c in call2] maid0 = dat.loc[dat['txcall'] == callsign, 'txgrid'].iat[0].strip() ll0 = mlocs.toLoc(maid0) #%% ax = figure().gca() m = Basemap(projection='merc', llcrnrlat=ll0[0] - 5, urcrnrlat=ll0[0] + 5, llcrnrlon=ll0[1] - 10, urcrnrlon=ll0[1] + 10, lat_ts=20, resolution='l') m.drawcoastlines() m.drawcountries() #m.drawmeridians(arange(0,360,30)) #m.drawparallels(arange(-90,90,30)) #%% plot self x, y = m(ll0[1], ll0[0]) m.plot(x, y, 'o', color='limegreen', markersize=8, markerfacecolor='none') #%% plot others #station = DataFrame(index=call2,columns =['muf_fact','latlon','midlatlon']) for c in call2: rxgrid = dat.loc[dat['rxcall'] == c, 'rxgrid'].iat[0].strip() latlon = mlocs.toLoc(rxgrid) # plot this station location (by Maidenhead) x, y = m(latlon[1], latlon[0]) m.plot(x, y, 'o', color='red', markersize=8, markerfacecolor='none') #%% estimate Ne distm, az = vdist(ll0[0], ll0[1], latlon[0], latlon[1])[:2] aoi = atan(distm / 2 / F2h) muf_fact = 1 / cos(aoi) # lat,lon where ray refracted (midpoint between stations) midlatlon = vreckon(ll0[0], ll0[1], distm / 2, az) # plot midpoint Ne x, y = m(midlatlon[1], midlatlon[0]) m.plot(x, y, 'o', color='blue', markersize=6) ax.set_title(f'WSPR {b} MHz')
def test_vincenty(self): if numpy is None: logging.warning('Vincenty not tested') return az = 38 sr = 3e3 lat2, lon2, a21 = vreckon(10, 20, sr, az) assert_allclose((lat2, lon2, a21), (10.02137267, 20.016847, 218.0029286)) if pyproj: p4lon, p4lat, p4a21 = pyproj.Geod(ellps='WGS84').fwd( lon2, lat2, az, sr) assert_allclose((p4lon, p4lat, p4a21 % 360.), (lon2, lat2, a21), rtol=0.0025) assert_allclose(vdist(10, 20, lat2, lon2), (sr, az, a21)) if pyproj: p4az, p4a21, p4sr = pyproj.Geod(ellps='WGS84').inv( 20, 10, lon2, lat2) assert_allclose((p4az, p4a21 % 360., p4sr), (az, a21, sr))
eng = None def matlab_func(lat1: float, lon1: float, lat2: float, lon2: float) -> typing.Tuple[float, float]: """ Using Matlab Engine to do same thing as Pymap3d """ ell = eng.wgs84Ellipsoid() return eng.distance(lat1, lon1, lat2, lon2, ell, nargout=2) dlast, alast = nan, nan lon1, lon2 = 0.0, 1.0 for i in range(20): lat1 = lat2 = 10.0**(-i) dist_m, az_deg = vdist(lat1, lon1, lat2, lon2) assert dist_m != dlast assert az_deg != alast mat_match = True dist_matlab, az_matlab = matlab_func(lat1, lon1, lat2, lon2) if not isclose(dist_matlab, dist_m): mat_match = False print( f"MISMATCH: latitude {lat1} {lat2}: Python: {dist_m} Matlab: {dist_matlab}", file=sys.stderr, ) if not isclose(az_matlab, az_deg): mat_match = False print( f"MISMATCH: latitude {lat1} {lat2}: Python: {az_matlab} Matlab: {az_deg}",
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') 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
#!/usr/bin/env python from pymap3d.vincenty import vdist if __name__ == '__main__': #pragma: no cover from argparse import ArgumentParser 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('distance between WGS-84 points: {} m'.format(dist_m))
stub += '&types={}'.format(place_type) stub += '&key={}'.format(key) r = requests.get(stub) r.raise_for_status() 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] return places 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') 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
mask = ~np.all(np.isnan(X), axis=(0, 2, 3)) X = X[:, mask, :, :] X[np.isnan(X)] = 0 y = np.concatenate(y, axis=0) strength = np.concatenate(strength, axis=0) if use_swind: SW = np.concatenate(SW, axis=0) # figure out good ordering for the stations (rows) station_locations = station_locations[mask] a = station_locations[:, None, :] * np.ones( (1, station_locations.shape[0], station_locations.shape[1])) locs = np.reshape(np.concatenate((a, np.transpose(a, [1, 0, 2])), axis=2), (-1, 4)).astype(float) d, a1, a2 = vdist(locs[:, 1], locs[:, 0], locs[:, 3], locs[:, 2]) dists = d.reshape((station_locations.shape[0], station_locations.shape[0])) dists[np.isnan(dists)] = 0 sa = anneal.SimAnneal(station_locations, dists, stopping_iter=100000000) sa.anneal() X = X[:, sa.best_solution, :, :] # save the dataset if use_swind: np.savez(output_fn, X=X, y=y, SW=SW, strength=strength) else: np.savez(output_fn, X=X, y=y, strength=strength) print("total storms: ", total_substorms) print("Number skipped because of storms out of region: ", n_out_of_region,
dtype=np.float32)) I, J = np.meshgrid(np.arange(X.shape[1]), np.arange(X.shape[0])) ss_map = np.zeros_like(X, dtype=np.float32) points = np.stack((X, Y), axis=2).reshape((-1, 2)) map_indices = np.stack((I, J), axis=2).reshape((-1, 2)) stations = stations.loc[[st for st in dataset]].values[:, :2].astype(np.float32) stations[stations[:, 0] > 180, 0] -= 360 padded_stations = np.concatenate((stations, np.zeros_like(stations)), axis=1) padded_points = np.concatenate((np.zeros_like(points), points), axis=1) arr = np.reshape(padded_points[:, None, :] + padded_stations[None, :, :], (points.shape[0] * stations.shape[0], 4)) lon1, lat1, lon2, lat2 = (arr[:, 0], arr[:, 1], arr[:, 2], arr[:, 3]) s, a12, a21 = vdist(lat1, lon1, lat2, lon2) s = np.reshape(s, (points.shape[0], stations.shape[0])) close_indices = np.argsort(s, axis=1) dates = dataset.Date_UTC.values dataset = dataset.to_array().values # station x time x component for t in range(T0, dataset.shape[1], 15): print(t) fig = plt.figure(figsize=(10, 10)) for pt in range(points.shape[0]): data = dataset[:, t - T0:t, :] top_k = [] for i in range(close_indices.shape[1]): if len(top_k) == N_STATIONS:
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") 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
def test_vdist(): dist_m = vdist(10, 20, 10.021372672660874, 20.016847098929979)[0] assert_almost_equal(dist_m, 2999.9999971763464)
import matplotlib.pyplot as plt import keras import numpy as np from pymap3d.vincenty import vdist import talos as ta X = np.random.rand(1000, 4) * [180, 360, 180, 360] - [90, 180, 90, 180] y, *_ = vdist(X[:, 0], X[:, 1], X[:, 2], X[:, 3]) y /= 1000 def distance_model(X, y, X_val, y_val, params): layers = [keras.layers.Dense(params['first_layer_units'], input_dim=4, activation=params['activation'])] for i in range(params['n_layers']): layers.append(keras.layers.Dense(params['n_units'], activation=params['activation'])) layers.append(keras.layers.Dense(1)) model = keras.models.Sequential(layers) model.compile(optimizer='adam', loss=params['loss'], metrics=['mae']) hist = model.fit(X, y, epochs=params['epochs'], batch_size=params['batch_size']) return hist, model # params = { # 'first_layer_units': np.logspace(6, 11, num=10, base=2).astype(int), # 'activation': [keras.activations.tanh, keras.activations.elu, keras.activations.sigmoid, keras.activations.relu], # 'n_layers': [1, 2, 3, 4, 5], # 'n_units': np.logspace(6, 11, num=10, base=2).astype(int), # 'loss': ['mse', 'mae'],
def test_unit(lat, lon, lat1, lon1, srange, az, backaz): dist, az1, backaz1 = vincenty.vdist(lat, lon, lat1, lon1) assert dist == approx(srange, rel=0.005) assert az1 == approx(az) assert backaz1 == approx(backaz)