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