def mapPoint(id=11):
#bbox
minx, maxx, miny, maxy = boundingBox(nahalal_basin)
current_pnt = gv.Points(smp_pnt.query("id=={}".format(id)))
pnts = gv.Points(smp_pnt, vdims=["id", "description"])
basin = gv.Contours(nahalal_basin)
# hovertool
hover = HoverTool(tooltips=[("Point #",
"@id"), ("Description", '@description')])
points_map = ((
gts.EsriImagery.opts(alpha=0.4) * gts.OSM.opts(alpha=0.4) *
basin.opts(color='chocolate', line_width=2, alpha=.5) *
gv.Path(kishon).opts(line_width=3.5,
alpha=0.4,
line_color="darkblue",
line_dash="dashed") *
gv.Path(nahalal).opts(line_width=2.5, alpha=0.4, line_color="blue") *
gv.Path(nahalal_sub).opts(
line_width=2, line_dash="dashdot", alpha=0.4, line_color="blue") *
pnts.opts(size=13, alpha=0.6, tools=[hover]) *
current_pnt.opts(size=20, color="purple")
# * gv.Contours(interest_zone).opts(alpha=0)
).opts(width=500,
height=375,
fontsize={
'labels': labels_fsize,
'xticks': tick_fsize,
'yticks': tick_fsize
}).redim.range(Longitude=(minx, maxx), Latitude=(miny, maxy)))
return points_map
def annotate(self,
data: List[gpd.GeoDataFrame],
raster_data: Tuple[Dict[str, np.array], np.array],
resolution=30,
**kwargs) -> Geometry:
raster_grid = np.flipud(raster_data[1])
start_x, start_y = snap_coords_to_grid(raster_data[0],
self.start_coord[1],
self.start_coord[0])
end_x, end_y = snap_coords_to_grid(raster_data[0], self.end_coord[1],
self.end_coord[0])
if raster_grid[start_y, start_x] < 0:
print('Start node in blocked area, path impossible')
return None
elif raster_grid[end_y, end_x] < 0:
print('End node in blocked area, path impossible')
return None
env = GridEnvironment(raster_grid, diagonals=False)
algo = self.algo(
heuristic=self.heuristic(env, risk_to_dist_ratio=self.rdr))
t0 = time()
if isinstance(algo, RiskThetaStar):
self.path = algo.find_path(env,
Node((start_y, start_x)),
Node((end_y, end_x)),
thres=self.thresh)
elif isinstance(algo, RiskGridAStar):
self.path = algo.find_path(env, Node((start_y, start_x)),
Node((end_y, end_x)))
if self.path is None:
print("Path not found")
return None
else:
print('Path generated in ', time() - t0)
# mpl.matshow(raster_data[1], cmap='jet')
# mpl.colorbar()
# mpl.plot([n.x for n in path], [n.y for n in path], color='red')
# mpl.title(
# f'Costmap \n Start (x,y):({snapped_start_lon_idx}, {snapped_start_lat_idx})'
# f'\n End (x,y):({snapped_end_lon_idx}, {snapped_end_lat_idx})')
# mpl.show()
snapped_path = []
for node in self.path:
lat = raster_data[0]['Latitude'][node.position[0]]
lon = raster_data[0]['Longitude'][node.position[1]]
snapped_path.append((lon, lat))
snapped_path = sg.LineString(snapped_path)
self.dataframe = gpd.GeoDataFrame({
'geometry': [snapped_path]
}).set_crs('EPSG:4326')
return gv.Contours(self.dataframe).opts(line_width=4,
line_color='magenta')
def annotate(self,
data: List[gpd.GeoDataFrame],
raster_data: Tuple[Dict[str, np.array], np.array],
resolution=20,
**kwargs) -> Overlay:
import geoviews as gv
import scipy.stats as ss
import joblib as jl
bounds = (raster_data[0]['Longitude'].min(),
raster_data[0]['Latitude'].min(),
raster_data[0]['Longitude'].max(),
raster_data[0]['Latitude'].max())
line_coords = list(self.dataframe.iloc[0].geometry.coords)
# Snap the line string nodes to the raster grid
snapped_points = [
snap_coords_to_grid(raster_data[0], *coords)
for coords in line_coords
]
# Generate pairs of consecutive (x,y) coords
path_pairs = list(map(list, zip(snapped_points, snapped_points[1:])))
headings = []
for i in range(1, len(line_coords)):
prev = line_coords[i - 1]
next = line_coords[i]
x = np.sin(next[0] - prev[0]) * np.cos(next[1])
y = np.cos(prev[1]) * np.sin(next[1]) - np.sin(prev[1]) * np.cos(
next[1]) * np.cos(next[0] - prev[0])
angle = (np.arctan2(x, y) + (2 * np.pi)) % (2 * np.pi)
headings.append(angle)
# Feed these pairs into the Bresenham algo to find the intermediate points
path_grid_points = [
bresenham.make_line(*pair[0], *pair[1]) for pair in path_pairs
]
for idx, segment in enumerate(path_grid_points):
n = len(segment)
point_headings = np.full(n, headings[idx])
path_grid_points[idx] = np.column_stack(
(np.array(segment), point_headings))
# Bring all these points together and remove duplicate coords
# Flip left to right as bresenham spits out in (y,x) order
path_grid_points = np.unique(np.concatenate(path_grid_points, axis=0),
axis=0)
bm = BallisticModel(self.aircraft)
samples = 1000
# Conjure up our distributions for various things
alt = ss.norm(self.alt, 5).rvs(samples)
vel = ss.norm(self.vel, 2.5).rvs(samples)
wind_vels = ss.norm(self.wind_vel, 1).rvs(samples)
wind_dirs = bearing_to_angle(
ss.norm(self.wind_dir, np.deg2rad(5)).rvs(samples))
wind_vel_y = wind_vels * np.sin(wind_dirs)
wind_vel_x = wind_vels * np.cos(wind_dirs)
# Create grid on which to evaluate each point of path with its pdf
raster_shape = raster_data[1].shape
x, y = np.mgrid[0:raster_shape[0], 0:raster_shape[1]]
eval_grid = np.vstack((x.ravel(), y.ravel())).T
def wrap_hdg_dists(alt, vel, hdg, wind_vel_y, wind_vel_x):
(mean, cov), v_i, a_i = bm.transform(
alt, vel,
ss.norm(hdg, np.deg2rad(2)).rvs(samples), wind_vel_y,
wind_vel_x, 0, 0)
return hdg, (mean / resolution, cov / resolution, v_i, a_i)
njobs = 1 if len(headings) < 3 else -1
# Hardcode backend to prevent Qt freaking out
res = jl.Parallel(n_jobs=njobs, backend='threading', verbose=1)(
jl.delayed(wrap_hdg_dists)(alt, vel, hdg, wind_vel_y, wind_vel_x)
for hdg in headings)
dists_for_hdg = dict(res)
def point_distr(c):
dist_params = dists_for_hdg[c[2]]
pdf = np.array(ss.multivariate_normal(
dist_params[0] + np.array([c[0], c[1]]),
dist_params[1]).pdf(eval_grid),
dtype=np.longdouble)
return pdf
sm = StrikeModel(raster_data[1].ravel(), resolution * resolution,
self.aircraft.width)
fm = FatalityModel(0.5, 1e6, 34)
ac_mass = self.aircraft.mass
def wrap_pipeline(path_point_state):
impact_pdf = point_distr(path_point_state)
impact_vel = dists_for_hdg[path_point_state[2]][2]
impact_angle = dists_for_hdg[path_point_state[2]][3]
impact_ke = velocity_to_kinetic_energy(ac_mass, impact_vel)
strike_pdf = sm.transform(impact_pdf, impact_angle=impact_angle)
fatality_pdf = fm.transform(strike_pdf, impact_ke=impact_ke)
return fatality_pdf, fatality_pdf.max(), strike_pdf.max()
res = jl.Parallel(n_jobs=-1, backend='threading',
verbose=1)(jl.delayed(wrap_pipeline)(c)
for c in path_grid_points)
fatality_pdfs = [r[0] for r in res]
# PDFs come out in input order so sorting not required
pathwise_fatality_maxs = np.array([r[1] for r in res],
dtype=np.longdouble)
pathwise_strike_maxs = np.array([r[2] for r in res],
dtype=np.longdouble)
import matplotlib.pyplot as mpl
import tempfile
import subprocess
fig, ax = mpl.subplots(1, 1)
path_dist = self.dataframe.to_crs('EPSG:27700').iloc[0].geometry.length
ax.set_yscale('log')
ax.set_ylim(bottom=1e-18)
x = np.linspace(0, path_dist, len(pathwise_fatality_maxs))
ax.axhline(
y=np.median(pathwise_fatality_maxs),
c='y',
label='Fatality Median') # This seems to be as stable as fsum
ax.plot(x, pathwise_fatality_maxs[::-1], c='r', label='Fatality Risk')
ax.axhline(y=np.median(pathwise_strike_maxs),
c='g',
label='Strike Median') # This seems to be as stable as fsum
ax.plot(x, pathwise_strike_maxs[::-1], c='b', label='Strike Risk')
ax.legend()
ax.set_ylabel('Risk [$h^{-1}$]')
ax.set_xlabel('Path Distance [m]')
ax.set_title('Casualty Risk along path')
tmppath = tempfile.mkstemp()[1] + '.png'
fig.savefig(tmppath)
subprocess.run("explorer " + tmppath)
risk_map = np.sum(fatality_pdfs,
axis=0).reshape(raster_shape) * self.event_prob
risk_raster = gv.Image(risk_map,
vdims=['fatality_risk'],
bounds=bounds).options(
alpha=0.7,
cmap='viridis',
tools=['hover'],
clipping_colors={'min': (0, 0, 0, 0)})
risk_raster = risk_raster.redim.range(fatality_risk=(risk_map.min() +
1e-15,
risk_map.max()))
print('Max probability of fatality: ', risk_map.max())
return Overlay([
gv.Contours(self.dataframe).opts(line_width=4,
line_color='magenta'), risk_raster
])
def mapDate(df):
smp_pnt_df = smp_pnt.merge(df, on='id').dropna().reset_index(drop=True)
basin = gv.Contours(nahalal_basin)
# bbox
minx, maxx, miny, maxy = boundingBox(nahalal_basin)
#valid results
if len(smp_pnt_df) > 0:
#clean column names
smp_pnt_df.columns = smp_pnt_df.columns.map(
lambda x: x.replace('-', '_'))
pol = smp_pnt_df.columns[-1]
print(pol)
cmap, symmetric, pname = cmapAndPName(pol)
# cmap/symmetric
if pol == 'pH':
smp_pnt_df['pH0'] = smp_pnt_df['pH'] - 7
#vdims
vdims = ["id", "description", pol]
if pol == 'pH':
vdims = vdims + ['pH0']
#pnts
pnts = gv.Points(smp_pnt_df, vdims=vdims)
if pol == 'pH':
pnts = gv.Points(smp_pnt_df, vdims=vdims)
hover = HoverTool(tooltips=[
("Point #", "@id"),
("Description", '@description'),
#("{}".format(yLabel(pol)), '(@{})'.format(pol))]
("{}".format(yLabel(pol)).replace('_', '-'), '@{}'.format(pol))
])
##map
points_map = ((gts.EsriImagery.opts(alpha=0.4) *
gts.OSM.opts(alpha=0.4) *
basin.opts(color='chocolate', line_width=2, alpha=.5) *
gv.Path(kishon).opts(line_width=3.5,
alpha=0.4,
line_color="darkblue",
line_dash="dashed") *
gv.Path(nahalal).opts(
line_width=2.5, alpha=0.4, line_color="blue") *
gv.Path(nahalal_sub).opts(line_width=2,
line_dash="dashdot",
alpha=0.4,
line_color="blue") *
pnts.opts(size=15,
alpha=0.8,
tools=[hover],
color_index=pname,
cmap=cmap,
line_color='purple',
symmetric=symmetric)).opts(
width=500,
height=375,
fontsize={
'labels': labels_fsize,
'xticks': tick_fsize,
'yticks': tick_fsize
}).redim.range(Longitude=(minx, maxx),
Latitude=(miny, maxy)))
else:
points_map = ((
gts.EsriImagery.opts(alpha=0.4) * gts.OSM.opts(alpha=0.4) *
basin.opts(color='chocolate', line_width=1.5, alpha=.5) *
gv.Path(kishon).opts(line_width=3.5,
alpha=0.4,
line_color="darkblue",
line_dash="dashed") *
gv.Path(nahalal).opts(line_width=2.5, alpha=0.4, line_color="blue")
* gv.Path(nahalal_sub).opts(line_width=2,
line_dash="dashdot",
alpha=0.4,
line_color="blue")).opts(
width=500,
height=375,
fontsize={
'labels': labels_fsize,
'xticks': tick_fsize,
'yticks': tick_fsize
}).redim.range(Longitude=(minx,
maxx),
Latitude=(miny,
maxy)))
return points_map