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 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)
