def run_tool(event): try: if DOCKER_CONTAINER == "True": if not os.path.exists(os.path.join('/data', 'outp')): os.makedirs(os.path.join('/data', 'outp')) data_regrid_fn, data_coarse = start_tool(inp_var.value, inp_data_type.value, os.path.join('/data', div_src_data.value.rsplit('\\',1)[-1]), os.path.join('/data', div_dst_topo.value.rsplit('\\',1)[-1]), os.path.join('/data', div_src_topo.value.rsplit('\\',1)[-1]), os.path.join('/data', 'outp'), json.loads(inp_lat.value)[0], json.loads(inp_lat.value)[1], json.loads(inp_lon.value)[0], json.loads(inp_lon.value)[1], int(inp_start_year.value), int(inp_end_year.value), regrid_method = inp_reg_method.value) else: data_regrid_fn, data_coarse = start_tool(inp_var.value, inp_data_type.value, div_src_data.text, div_dst_topo.text, div_src_topo.text, div_dir_dest.text, json.loads(inp_lat.value)[0], json.loads(inp_lat.value)[1], json.loads(inp_lon.value)[0], json.loads(inp_lon.value)[1], int(inp_start_year.value), int(inp_end_year.value), regrid_method = inp_reg_method.value) data_regrid = xr.open_dataset(data_regrid_fn) # Plot renderer = gv.renderer('bokeh') dataset_coarse = gv.Dataset(data_coarse[inp_var.value].groupby('time.season').mean('time'), kdims=['season', 'lon', 'lat'], crs=crs.PlateCarree()) dataset_regrid = gv.Dataset(data_regrid[inp_var.value].groupby('time.season').mean('time'), kdims=['season', 'lon', 'lat'], crs=crs.PlateCarree()) gv_plot = renderer.get_plot( (dataset_coarse.to(gv.Image, ['lon','lat']).options(width=350, colorbar=True, alpha=0.6, title="Coarse data") * gv.WMTS(tiles['Wikipedia'])) + \ (dataset_regrid.to(gv.Image, ['lon','lat']).options(width=350, colorbar=True, alpha=0.6, title="Downscaled data") * gv.WMTS(tiles['Wikipedia'])) ) inp_sel_season = bmo.widgets.Select(title="Season:", value="DJF", options=["DJF","JJA","MAM","SON"]) inp_sel_season.on_change('value', lambda attrname, old, new: gv_plot.update((new,))) l.children[-1] = bo.layouts.layout(bo.layouts.row([inp_sel_season]), bo.layouts.row([gv_plot.state])) div_spinner.text = done_text except Exception as e: div_spinner.text = error_text print("------------- ERROR -------------") print(e.args)
def shapeplot(dframe, var, coords, raxis, cm='Jet_r', extralayers=[], lcolor='black'): lcoords = len(coords) xly = len(extralayers) if lcoords == 2 and xly > 0: gvdata = gv.Dataset(dframe, kdims=[coords[0], coords[1], raxis], vdims=var) back = gvdata.to(gv.Image, [coords[0], coords[1]], var) back = back.opts(colorbar=True, backend='bokeh', cmap=cm, width=600, height=400) for layer in extralayers: ss = gv.Shape.from_shapefile(layer).opts(line_color=lcolor) back *= ss return gv.output(back.opts(width=600, height=400), backend='bokeh') else: print("Incomplete coordinates")
def to_geoimage(data, dynamic=True, style_opts={'cmap': 'RdBu_r'}, plot_opts={ 'width': 600, 'toolbar': 'above', 'colorbar': True }, hover=False): gvd = gv.Dataset(data) if len(gvd.dimensions()) < 4: gvimg = gvd.to(gv.Image, kdims=['lon', 'lat'])(plot=plot_opts)(style=style_opts) else: gvimg = gvd.to(gv.Image, kdims=['lon', 'lat'], dynamic=dynamic)(plot=plot_opts)(style=style_opts) if hover: projected = gv.operation.project_image(gvimg) gvimg = hv.QuadMesh( projected, kdims=gvimg.kdims, vdims=gvimg.vdims)(plot=plot_opts)(style=style_opts) gvimg = gvimg(plot={'tools': ['hover']}) #gvimg*=gvd.to(gv.Points,kdims=['lon','lat'])(style={'alpha':0,'marker':'square','size':6})(plot={'tools':['hover']}) return gvimg #*gv.feature.coastline
def index(document): # Load some data path = "~/cache/highway_ga6_20190315T0000Z.nc" air_temperature = xarray.open_dataset(path).air_temperature dataset = gv.Dataset(air_temperature[0]) contours = dataset.to(gv.LineContours, ['longitude_0', 'latitude_0']) # Create map feature = (gf.land * gf.ocean * gf.lakes * gf.rivers * gf.coastline * gf.borders * contours).opts(global_extent=True, xaxis=None, yaxis=None, border=0, active_tools=["pan", "wheel_zoom"]) figure = renderer.get_plot(feature).state figure.sizing_mode = "stretch_both" figure.aspect_ratio = 1 figure.axis.visible = False figure.toolbar.logo = None figure.toolbar_location = None figure.title.text = "" contours.data = air_temperature[-1] document.add_root( bokeh.layouts.row(figure, name="map", sizing_mode="stretch_both")) document.template = template.INDEX
def variable_update(event): global path, fram_data, curr_var, min_range, max_range, control_path, control_data, global_data, global_path, gv_geo_plot, curr_dataset, curr_intervention, DATA_DICT path = './iceClinic/data/f09_g16.B.cobalt.FRAM.MAY.{}.200005-208106.nc'.format(event.item) control_path = './iceClinic/data/f09_g16.B.cobalt.CONTROL.MAY.{}.200005-208106.nc'.format(event.item) global_path = './iceClinic/data/f09_g16.B.cobalt.GLOBAL.MAY.{}.200005-208106.nc'.format(event.item) curr_var = event.item fram_data = xr.open_dataset(path) control_data = xr.open_dataset(control_path) global_data = xr.open_dataset(global_path) DATA_DICT = {'CONTROL': control_data, 'FRAM' : fram_data, 'GLOBAL' : global_data} curr_dataset = DATA_DICT[curr_intervention] dataset = gv.Dataset(curr_dataset) stateBasemap = gv.Feature(feature.STATES) gv_geo_plot = dataset.to(gv.Image, ['lon', 'lat'], curr_var, dynamic=True).opts(title = '{} Intervention, {} data'.format(curr_intervention, curr_var), cmap=CMAP_DICT[curr_var], colorbar=True, backend='bokeh', projection = crs.PlateCarree()) *gf.coastline() * gf.borders() * stateBasemap.opts(fill_alpha=0,line_width=0.5) #control_min_range, control_max_range = getMinMax(control_data, curr_var) #print(control_min_range, control_max_range) fram_min_range, fram_max_range = getMinMax(fram_data, curr_var) global_min_range, global_max_range = getMinMax(global_data, curr_var) min_range = min(fram_min_range, global_min_range) max_range = max(fram_max_range,global_max_range) gv_geo_plot = gv_geo_plot.redim(**{curr_var:hv.Dimension(curr_var, range=(min_range, max_range))}) var_stream.event(var=event.item)
def plotMap(self, dArray, name, width=500, height=250, cmap="gist_earth_r", dataShader=True, alpha=0.5): """ plot the DataArray onto the map. Args: dArray (xarray.DataArray): DataArray of your output. name (str): name of your data width (int): width of the output image height (int): height of the output image cmap (str): colormap alpha (float): alpha value Returns: bokeh image object """ dataset = gv.Dataset(dArray) img = dataset.to(gv.Image, ["lon", "lat"], name) if dataShader: img = datashader.regrid(img) img_out = img.opts(width=width, height=height, alpha=alpha, colorbar=True, cmap=cmap, tools=["hover"]) * self.mapTiles return img_out
def plot_polling_place_vote(df, backend, year, electorate=None, color_range=None): """Setup for plotting the vote at each polling place.""" assert backend in ['bokeh', 'matplotlib'] if electorate: plot_df = df[df['DivisionNm'] == electorate] else: plot_df = df votes = gv.Dataset(plot_df, kdims=['GreensPercentage', 'TotalVotes']) points = votes.to( gv.Points, ['Longitude', 'Latitude'], ['PollingPlaceNm', 'GreensVotes', 'TotalVotes', 'GreensPercentage']) title = 'Greens senate primary vote, %s Federal Election' % (str(year)) if electorate: title = title + ' (' + electorate + ')' if backend == 'bokeh': points = points.opts(color='GreensPercentage', cmap='Greens', size=10, tools=['hover'], width=600, height=600, padding=0.1, colorbar=True, line_color='black', title=title, clabel='%', xaxis=None, yaxis=None) #size=dim('TotalVotes')*0.015, background = gv.tile_sources.Wikipedia else: points = points.opts(color='GreensPercentage', cmap='Greens', s=30, padding=0.1, colorbar=True, title=title, clabel='%', xaxis=None, yaxis=None) #background = gvts.CartoEco #background = background.opts(zoom=7, projection=ccrs.PlateCarree()) background = gv.tile_sources.Wikipedia #background = background.opts(zoom=10) if color_range: points = points.redim.range(GreensPercentage=color_range) return points * background
def geoview_flat_plot(region_da, time_sel=0, level_sel=False, wide_chile=True): if type(level_sel) is int: da = region_da.isel(level=level_sel) else: da = region_da gv_ds = gv.Dataset(da.isel(time=time_sel)) plot = gv_ds.to(gv.Image, ['lon', 'lat'], 't', 'time').opts(cmap='viridis', colorbar=True) extras = [] if wide_chile: easter_island_text = gv.Text(-104.360481, -24.104671, 'Easter Island').opts(color='white') easter_island_point = gv.Points([(-109.360481, -27.104671)]).opts(color='red') easter = easter_island_point * easter_island_text falkland_islands_text = gv.Text(-49.563412, -56.820557, 'Falklands').opts(color='white') falkland_islands_point = gv.Points([(-51.563412, -59.820557)]).opts(color='red') falkland = falkland_islands_point * falkland_islands_text extras.append(easter * falkland) plot = contours(plot, filled=True, overlaid=True) with warnings.catch_warnings(): warnings.simplefilter("ignore") final_plot = plot * gf.coastline for extra in extras: final_plot *= extra gv.output(final_plot)
def to_geoimage(data, dynamic=True, style_opts={'cmap': 'RdBu_r'}, plot_opts={ 'width': 600, 'xaxis': None, 'yaxis': None, 'toolbar': 'above', 'colorbar': True }, hover=False): gvd = gv.Dataset(data) if len(gvd.dimensions()) < 4: gvimg = gvd.to(gv.Image, kdims=['lon', 'lat'])(plot=plot_opts)( style=style_opts) * gv.feature.coastline else: gvimg = gvd.to(gv.Image, kdims=['lon', 'lat'], dynamic=dynamic)( plot=plot_opts)(style=style_opts) * gv.feature.coastline if hover: gvimg *= gvd.to(gv.Points, kdims=['lon', 'lat'])(style={ 'alpha': 0, 'marker': 'square', 'size': 6 })(plot={ 'tools': ['hover'] }) return gvimg
def intervention_update(event): global curr_var, DATA_DICT, control_data, curr_intervention, gv_geo_plot, min_range, max_range curr_intervention = event.item curr_ds = DATA_DICT[event.item] dataset = gv.Dataset(curr_ds) gv_geo_plot = dataset.to(gv.Image, ['lon', 'lat'], curr_var, dynamic=True).opts(title = '{} Intervention, {} data'.format(curr_intervention, curr_var), cmap=CMAP_DICT[curr_var], colorbar=True, backend='bokeh', projection = crs.PlateCarree()) *gf.coastline() * gf.borders() * stateBasemap.opts(fill_alpha=0,line_width=0.5) gv_geo_plot = gv_geo_plot.redim(**{curr_var:hv.Dimension(curr_var, range=(min_range, max_range))}) intervention_stream.event(intervention=event.item)
def make_view(self): dfc = stations[stations['contractName'] == self.city_name] gv_df = gv.Dataset( dfc[['longitude', 'latitude', 'name', 'bikes_available_total']]) points = gv_df.to(gv.Points, ['longitude', 'latitude'], ['name', 'bikes_available_total']) return (tiles * points).opts( opts.Points(tools=['hover'], size=dim('bikes_available_total'), color='bikes_available_total', cmap='viridis'))
def view_map(self): sample_map = arr_temp.where( (arr_temp.omega == self.omega) & (arr_temp.C_11 == self.c11) & (arr_temp.delta_phi == self.delta_phi), drop=True) dataset = gv.Dataset(sample_map, ['longitude', 'latitude', 'omega', 'C_11'], 'surface_temperature') images = dataset.to(gv.Image, ['longitude', 'latitude'], 'surface_temperature') images.opts(cmap='viridis', colorbar=True, width=400, height=250) return images
def update_map(attr, old, new): global selection, vizual, gvplot, hvplot, heatmap, feats, points, world_map, range_slider, controls3, max_cur_feature, min_cur_feature, temp_feats max_cur_feature = temp_feats[choice.value].max() min_cur_feature = temp_feats[choice.value].min() range_slider = RangeSlider(start=min_cur_feature, end=max_cur_feature, value=(min_cur_feature, max_cur_feature), step=(max_cur_feature - min_cur_feature) / 20, title="Feature_range") range_slider.on_change('value', update_map_val) controls3 = widgetbox([range_slider], width=250) new_loc_feats = temp_feats.loc[ (temp_feats[choice.value] < range_slider.value[1]) & (temp_feats[choice.value] > range_slider.value[0])] feats = gv.Dataset(new_loc_feats, kdims=['Longitude', 'Latitude', new]) points = feats.to(gv.Points, ['Longitude', 'Latitude'], [new]) if len(new_loc_feats) <= 20000: world_map = gv.Overlay(tiles * points).options( 'Points', size=5, cmap='viridis', colorbar=True, tools=TOOLS, color_index=2, width=900, height=800, global_extent=True, colorbar_opts={'scale_alpha': 0.5}, fill_alpha=0.5, line_alpha=0.5) else: world_map = decimate(gv.Points(points), max_samples=20000).options( 'Points', size=5, cmap='viridis', colorbar=True, tools=TOOLS, color_index=2, width=900, height=800, global_extent=True, colorbar_opts={'scale_alpha': 0.5}, fill_alpha=0.5, line_alpha=0.5) selection = hv.streams.Selection1D(source=world_map) heatmap = hv.DynamicMap(selected_points, streams=[selection]) zoom = hv.DynamicMap(test_bounds, streams=[box]) hvplot = renderer.get_plot(heatmap, curdoc()) gvplot = renderer.get_plot(world_map, curdoc()) bvplot = renderer.get_plot(zoom, curdoc()) vizual.children[1].children = [gvplot.state, hvplot.state, bvplot.state]
def __init__(self, **kwargs): super(LayoutDashBoard, self).__init__() ds = xr.open_dataset(os.path.join(dataDir, kwargs['filename'])) long=np.linspace(-180, 180, 900, dtype='float32') ds['longitude'] = long ds_out = ds.sel(latitude=slice(-22, -27), longitude=slice(-46, -41)) dataset = gv.Dataset(ds_out, ['longitude', 'latitude', 'time'],'u10',crs=crs.PlateCarree()) images = dataset.to(gv.Image) im = images.opts(cmap='viridis', alpha=0.4, colorbar=True, width=600, height=500) self.app = im * gvts.EsriImagery
def graph(cube): title = cube.standard_name.title().replace('_', ' ') dataset = gv.Dataset(cube) plot = dataset.to(hv.Curve, label=title, group='') renderer = hv.Store.renderers['matplotlib'] renderer.size = 200 img_data = io.BytesIO() renderer.save(plot, img_data) img_data.seek(0) s3_url = upload_image(img_data) return s3_url
def plot_polling_place_swing(df, backend, year, electorate=None, color_range=None): """Setup for plotting the swing at each polling place. This will remove all polling places that don't exist in both the current and previous election. """ assert backend in ['bokeh'] if electorate: plot_df = df[df['DivisionNm'] == electorate].dropna() else: plot_df = df.dropna() votes = gv.Dataset(plot_df, kdims=['Swing', 'GreensVotes']) points = votes.to(gv.Points, ['Longitude', 'Latitude'], ['PollingPlaceNm', 'TotalVotes', 'GreensVotes', 'Swing']) title = 'Greens senate swing, %s Federal Election' % (str(year)) if electorate: title = title + ' (' + electorate + ')' if backend == 'bokeh': points = points.opts(color='Swing', cmap='RdBu_r', size=10, tools=['hover'], width=600, height=600, padding=0.1, colorbar=True, line_color='black', title=title, clabel='%', xaxis=None, yaxis=None) # size=dim('GreensVotes')*0.1 if color_range: points = points.redim.range(Swing=color_range) background = gv.tile_sources.Wikipedia return points * background
def fastplot(dframe, var, coords, raxis, cm='Jet'): lcoords = len(coords) if lcoords == 2: gvdata = gv.Dataset(dframe, kdims=[coords[0], coords[1], raxis], vdims=var) back = gvdata.to(gv.Image, [coords[0], coords[1]], var) return gv.output(back.opts(colorbar=True, backend='bokeh', cmap=cm, width=600, height=400), backend='bokeh') else: print("Incomplete coordinates")
def make_spatio_temporal_vel_point_obj(date): opts = dict(color='w', marker='v', size=3, line_color="r", tools=["hover"]) idx = spatio_temporal_vel_data_tab_df["starttime"] == date emax_avg_df = spatio_temporal_vel_data_tab_df[idx] ds = gv.Dataset((emax_avg_df["longitude"], emax_avg_df["latitude"], emax_avg_df["e_max"], emax_avg_df["station"]), ["Longitude", "Latitude"], ["Velocity Changes (%)", "Station"], crs=crs.PlateCarree()) vdims = [("e_max", "Velocity Changes (%)"), "Station"] spatio_temporal_vel_point_obj = ds.to(gv.Points, ["Longitude", "Latitude"], crs=ccrs.PlateCarree()) spatio_temporal_vel_point_obj = spatio_temporal_vel_point_obj.opts(**opts) print("make_spatio_temporal_vel_point_obj {}".format(date)) return (spatio_temporal_vel_point_obj)
def quick_map(da, dims=["lon", "lat"], redim_range=None, **user_options): options = dict( cmap="viridis", colorbar=True, fig_size=300, projection=crs.Robinson(central_longitude=180), ) options.update(user_options) name = da.name dataset = gv.Dataset(da) image = dataset.to(gv.Image, dims, dynamic=True).options(**options) if redim_range is not None: image = image.redim.range(**{name: redim_range}) return gv.output(image * gf.coastline(), backend="matplotlib")
def _make_heatmap(final_grid, density, fname, target): logger.info('Drawing the heatmap') lat = np.linspace(-90, 90, num=180 * density + 1) lon = np.linspace(-179.75, 180, num=360 * density) d = { 'coords': { 'latitude': { 'dims': ('latitude', ), 'data': lat }, 'longitude': { 'dims': ('longitude', ), 'data': lon } }, 'attrs': { 'title': '%s latency heatmap' % target }, 'dims': ['latitude', 'longitude'], 'data_vars': { 'latency': { 'dims': ('latitude', 'longitude'), 'data': final_grid } } } xr_set = xr.Dataset.from_dict(d) xr_dataset = gv.Dataset(xr_set, kdims=['latitude', 'longitude'], vdims=['latency'], crs=crs.PlateCarree()) hv.output(dpi=200, size=500) hv.opts("Image [colorbar=True clipping_colors={'min': 'lightgrey'}]") main_layer = xr_dataset.redim(latency=dict(range=(30, 90))).to( gv.Image, ['longitude', 'latitude']) img = gf.land * main_layer * gf.ocean * gf.borders if fname.endswith('.png'): fname = fname[:-4] renderer = hv.renderer('matplotlib').instance(fig='png') renderer.save(img, fname, style=dict(Image={'cmap': 'RdYlGn_r'}))
def view_time_series(filename, cmap='jet'): """ Visualize and interact with time series netcdf files. """ # Open geoviews interactive session. gv.extension('bokeh', 'matplotlib') with xr.open_dataset(filename, decode_times=False) as da: dataset = gv.Dataset(da) ensemble = dataset.to(gv.Image, ['x', 'y']) gv.output(ensemble.opts(cmap=cmap, colorbar=True, fig_size=200, backend='matplotlib'), backend='matplotlib') return
def plot_map(data, label, agg_data, agg_name, cmap): url = "http://server.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Base/MapServer/tile/{Z}/{Y}/{X}.png" geomap = gv.WMTS(url) points = hv.Points(gv.Dataset(data, kdims=['x', 'y'], vdims=[agg_name])) agg = datashade(points, element_type=gv.Image, aggregator=agg_data, cmap=cmap) zip_codes = dynspread(agg, threshold=T, max_px=PX) hover = hv.util.Dynamic(rasterize(points, aggregator=agg_data, width=50, height=25, streams=[RangeXY]), operation=hv.QuadMesh) hover = hover.options(cmap=cmap) img = geomap * zip_codes * hover img = img.relabel(label) return img
def update_map_val(attr, old, new): global selection, vizual, gvplot, hvplot, heatmap, feats, points, world_map, temp_feats max_cur_feature = loc_feats[choice.value].max() min_cur_feature = loc_feats[choice.value].min() new_loc_feats = temp_feats.loc[(temp_feats[choice.value] <= new[1]) & (temp_feats[choice.value] >= new[0])] feats = gv.Dataset(new_loc_feats, kdims=['Longitude', 'Latitude', choice.value]) points = feats.to(gv.Points, ['Longitude', 'Latitude'], [choice.value]) if len(new_loc_feats) <= 20000: world_map = gv.Points(points).options( 'Points', size=5, cmap='viridis', colorbar=True, tools=TOOLS, color_index=2, width=900, height=800, colorbar_opts={'scale_alpha': 0.5}, fill_alpha=0.5, line_alpha=0.5) else: world_map = decimate(gv.Points(points), max_samples=20000).options( 'Points', size=5, cmap='viridis', colorbar=True, tools=TOOLS, color_index=2, width=900, height=800, colorbar_opts={'scale_alpha': 0.5}, fill_alpha=0.5, line_alpha=0.5) selection = hv.streams.Selection1D(source=world_map) heatmap = hv.DynamicMap(selected_points, streams=[selection]) box = hv.streams.BoundsXY(source=world_map) zoom = hv.DynamicMap(test_bounds, streams=[box]) hvplot = renderer.get_plot(heatmap, curdoc()) gvplot = renderer.get_plot(world_map, curdoc()) bvplot = renderer.get_plot(zoom, curdoc()) vizual.children[1].children = [gvplot.state, hvplot.state, bvplot.state]
def interactive_plot(cube, cmap='viridis', kdims=['longitude', 'latitude'], coastlines=False, coastline_color='white', projection=ccrs.PlateCarree, tools=['hover'], min_height=600, **opts): # Generate an interactive Bokeh image of a cube with various plotting options # Convert cube to GeoViews dataset dataset = gv.Dataset(cube, [coord.name() for coord in cube.dim_coords], label=cube.name()) # Generate an image object which will dynamically render as the interactive view changes image = regrid(dataset.to(gv.Image, kdims, dynamic=True)) # Options for plotting options = { 'cmap': cmap, 'responsive': True, 'projection': projection(), 'colorbar': True, 'min_height': min_height, 'aspect': 2, 'tools': tools } # Include coastlines if needed if coastlines: return gv.feature.ocean * gv.feature.land * image.opts( **options, ** opts) * gv.feature.coastline.opts(line_color=coastline_color) else: return image.opts(**options, **opts)
def interactive_map(v1, options): # print(options) import cartopy.crs as ccrs import holoviews as hv from holoviews import opts, dim import geoviews as gv import geoviews.feature as gf import simplekml hv.extension("bokeh", "matplotlib") vname = v1.columns.tolist()[0] stretch = [0, 100] tres = np.median(np.diff(v1.index.tolist())) tres = 1 * int(tres.total_seconds() / 60) # vf1 = dataset.ts_aggregate_timebins(v1.to_frame(), time_bin=tres, operations={'': np.nanmean}, index_position='middle') # come up with leg coloring leg_series = dataset.add_legs_index(v1)["leg"] vcol = dataset.ts_aggregate_timebins( v1, time_bin=tres, operations={"": options["resampling_operation"]}, index_position="initial", ) vcol.columns = ["color"] min_ = np.percentile(vcol.dropna(), stretch[0]) max_ = np.percentile(vcol.dropna(), stretch[1]) # print(min_,max_) vcol[vcol < min_] = min_ vcol[vcol > max_] = max_ coordinates_raw = dataset.read_standard_dataframe( options["gps_file"])[["latitude", "longitude"]] # mode_ = lambda x : stats.mode(x)[0] # Deal with coordinates coordinates = dataset.ts_aggregate_timebins( coordinates_raw, time_bin=int(np.floor(options["map_temporal_aggregation"] * 60)), operations={"": np.nanmedian}, index_position="initial", ) # Resample and merge coordinates + data to_plot = pd.merge(coordinates, v1, left_index=True, right_index=True) to_plot = pd.merge( to_plot, pd.DataFrame(data=to_plot.index.tolist(), columns=["date"], index=to_plot.index), left_index=True, right_index=True, ) to_plot = to_plot.dropna() if options["kml_file"]: kml_ = simplekml.Kml() fol = kml_.newfolder(name="LV_KML") colz = (to_plot.loc[:, vname] - to_plot.loc[:, vname].min()) / ( to_plot.loc[:, vname].max() - to_plot.loc[:, vname].min()) colz = np.floor(255 * plt.cm.Spectral_r(colz.values)).astype(int) c = 0 for lat, lon, val, date in to_plot.values: # print(lat, lon, val, date) # print(row[1].loc['LV#11']) pnt = fol.newpoint(name=str(date), coords=[(lon, lat)]) pnt.style.iconstyle.icon.href = ( "http://maps.google.com/mapfiles/kml/shapes/shaded_dot.png") pnt.style.iconstyle.scale = 1 # Icon thrice as big pnt.style.iconstyle.color = simplekml.Color.rgb( colz[c, 0], colz[c, 1], colz[c, 2], 255) pnt.style.labelstyle.scale = 0.5 c += 1 kml_.save(options["kml_file"]) # colorbar limits min_v1 = min_ # np.percentile(to_plot.loc[:,vname].dropna(), stretch[0]) max_v1 = max_ # np.percentile(to_plot.loc[:,vname].dropna(), stretch[1]) # Create geoviews datasets v1_tomap = hv.Dataset( to_plot.loc[:, ["longitude", "latitude", "date", vname]], kdims=["longitude", "latitude"], vdims=[hv.Dimension(vname, range=(min_v1, max_v1))], group=vname, ) points_v1 = v1_tomap.to(gv.Points, kdims=["longitude", "latitude"]) gps_track = gv.Dataset(coordinates_raw) track = gv.Path(gps_track, kdims=["longitude", "latitude"]) # land_ = gf.land#.options(facecolor='red') point_map_v1 = points_v1.opts( projection=ccrs.SouthPolarStereo(), cmap=options["colormap"], size=5, tools=["hover"], # ['hover'], width=500, height=400, color_index=2, colorbar=True, ) track_map = track.opts(projection=ccrs.SouthPolarStereo()).opts( color="black") return (gf.land * gf.coastline * track_map * point_map_v1).opts( title=vname, width=options["figsize"][0], height=options["figsize"][1])
def test_bounds(bounds): global selection, vizual, gvplot, hvplot, heatmap, feats, points, world_map, range_slider, controls3, max_cur_feature, min_cur_feature, temp_feats if bounds != None: min_long = min(bounds[0], bounds[2]) max_long = max(bounds[0], bounds[2]) min_lat = min(bounds[1], bounds[3]) max_lat = max(bounds[1], bounds[3]) downscale_feats = loc_feats.loc[(loc_feats['Longitude'] >= min_long) & (loc_feats['Longitude'] <= max_long) & (loc_feats['Latitude'] >= min_lat) & (loc_feats['Latitude'] <= max_lat)] temp_feats = downscale_feats max_cur_feature = temp_feats[choice.value].max() min_cur_feature = temp_feats[choice.value].min() range_slider = RangeSlider(start=min_cur_feature, end=max_cur_feature, value=(min_cur_feature, max_cur_feature), step=(max_cur_feature - min_cur_feature) / 20, title="Feature_range") range_slider.on_change('value', update_map_val) controls3 = widgetbox([range_slider], width=250) new_loc_feats = temp_feats.loc[ (temp_feats[choice.value] <= range_slider.value[1]) & (temp_feats[choice.value] >= range_slider.value[0])] feats = gv.Dataset(new_loc_feats, kdims=['Longitude', 'Latitude', choice.value]) points = feats.to(gv.Points, ['Longitude', 'Latitude'], [choice.value]) if len(new_loc_feats <= 20000): world_map = gv.Points(points).options( 'Points', size=5, cmap='viridis', colorbar=True, tools=TOOLS, color_index=2, width=900, height=800, colorbar_opts={'scale_alpha': 0.5}, fill_alpha=0.5, line_alpha=0.5) else: world_map = decimate(gv.Points(points), max_samples=20000).options( 'Points', size=5, cmap='viridis', colorbar=True, tools=TOOLS, color_index=2, width=900, height=800, colorbar_opts={'scale_alpha': 0.5}, fill_alpha=0.5, line_alpha=0.5) selection = hv.streams.Selection1D(source=world_map) heatmap = hv.DynamicMap(selected_points, streams=[selection]) box = hv.streams.BoundsXY(source=world_map) zoom = hv.DynamicMap(test_bounds, streams=[box]) hvplot = renderer.get_plot(heatmap, curdoc()) gvplot = renderer.get_plot(world_map, curdoc()) bvplot = renderer.get_plot(zoom, curdoc()) vizual.children[1].children = [ gvplot.state, hvplot.state, bvplot.state ] vizual.children[0].children[2] = controls3 else: bounds = (0, 0, 0, 0) return hv.Bounds(bounds).options(show_grid=False, height=0, width=0, xaxis=None, yaxis=None, default_tools=[], show_frame=False, toolbar=None)
plot = fram_plot * control_plot * global_plot labels = {'TS':'Temperature (C)', 'PRECT' : "Precipitation (mm/day)", "SPI" : "Standardized Precipitation Index", "FWI" : "Fosberg Fire Weather Index"} return plot.opts(width=500, framewise=True, title='{} timeseries data'.format(curr_var), ylabel=labels[var]) stream = hv.streams.Stream.define('time_step', time_step=cftime.DatetimeNoLeap(2000, 6, 1))() var_stream = hv.streams.Stream.define('Var', var="TS")() lat_stream = hv.streams.Stream.define('Lat', lat=45)() lon_stream = hv.streams.Stream.define('Lon', lon=122)() intervention_stream = hv.streams.Stream.define('intervention', intervention="FRAM")() dmap = hv.DynamicMap(geo_plot, streams=[stream, var_stream, intervention_stream]).opts(width=600) dataset = gv.Dataset(curr_dataset) stateBasemap = gv.Feature(feature.STATES) gv_geo_plot = dataset.to(gv.Image, ['lon', 'lat'], 'TS', dynamic=True).opts( title = '{} Intervention, {} data'.format(curr_intervention, curr_var), cmap='coolwarm', colorbar=True, backend='bokeh', projection = crs.PlateCarree()) * gf.coastline() * gf.borders() * stateBasemap.opts(fill_alpha=0,line_width=0.5) gv_geo_plot = gv_geo_plot.redim(TS=hv.Dimension(curr_var, range=(min_range, max_range))) dmap_time_series = hv.DynamicMap(timeseries, streams=[var_stream, lat_stream, lon_stream]).opts(width=500, framewise=True) #Main function that processes incoming events and defines the current layout def modify_doc(doc): # Bokeh renderers that hold current viz as its state hvplot = renderer.get_plot(dmap, doc) timeseriesPlot = renderer.get_plot(dmap_time_series, doc) def animate_update(): year = slider.value + 1
def plot_grids(data,fields,plot_type): if len(data) == 2: ds,grid_ds = data if fields == 'Sources': print('Plotting Sources..') event_times_seconds = xr.DataArray(ds.event_time.values.astype('<m8[s]')/86400,dims='number_of_events') event_times_seconds.shape,ds.event_time.shape dss = ds.copy() dss['times'] = event_times_seconds.astype(int) xr_dataset = gv.Dataset(hv.Points((dss.event_longitude.values, dss.event_latitude.values,dss.times.values), kdims=[hv.Dimension('x'),hv.Dimension('y')],vdims=['time'])) fig = gv.tile_sources.Wikipedia.opts(width=900, height=900) * xr_dataset.to.points(['x','y']).opts(opts.Points(color='time')) else: print(plot_type) z = grid_ds.flash_extent_density x = grid_ds.grid_longitude.values y = grid_ds.grid_latitude.values # get xarray dataset, suited for handling raster data in pyviz xr_dataset = gv.Dataset(hv.Image((x, y, np.log10(z.mean(axis=0))), bounds=(x.min(),y.min(),x.max(),y.max()), kdims=[hv.Dimension('x'), hv.Dimension('y')], datatype=['grid'])) # create contours from image gv.FilledContours(xr_dataset) fig = gv.tile_sources.Wikipedia.opts(width=900, height=900) * xr_dataset.to.image(['x', 'y']).opts(cmap='cubehelix', alpha=0.8)#gv.FilledContours(xr_dataset).opts(cmap='viridis', alpha=0.5) responsive = pn.pane.HoloViews(fig, config={'responsive': True}) return(responsive) else: grid_ds = data print('No Data Processed') if fields == 'Sources': xr_dataset = gv.Dataset(hv.Points((np.repeat(-101.1,1), np.repeat(32,2),np.repeat(10,2)), kdims=[hv.Dimension('x'),hv.Dimension('y')],vdims=['time'])) fig = gv.tile_sources.Wikipedia.opts(width=900, height=900) * xr_dataset.to.points(['x','y']).opts(opts.Points(color='time')) elif plot_type == 'Grids': z = np.random.randn(10,(100,100)) x = np.repeat(-101.1,100) y = np.repeat(32,100) # get xarray dataset, suited for handling raster data in pyviz xr_dataset = gv.Dataset(hv.Image((x, y, np.log10(z)), bounds=(x.min(),y.min(),x.max(),y.max()), kdims=[hv.Dimension('x'), hv.Dimension('y')], datatype=['grid'])) # create contours from image gv.FilledContours(xr_dataset) fig = gv.tile_sources.Wikipedia.opts(width=900, height=900) * xr_dataset.to.image(['x', 'y']).opts(cmap='cubehelix', alpha=0.8)#gv.FilledContours(xr_dataset).opts(cmap='viridis', alpha=0.5) responsive = pn.pane.HoloViews(fig, config={'responsive': True}) return(responsive)
ds_psl = xr.open_mfdataset('/nobackup_3/users/stoop/7A_weather_data/psl_d_ECEarth_2C_s16r09_2064_world.nc') ds_rsds = xr.open_mfdataset('/nobackup_3/users/stoop/7A_weather_data/rsds_d_ECEarth_2C_s16r09_2064_world.nc') ds_wind = xr.open_mfdataset('/nobackup_3/users/stoop/7A_weather_data/sfcwind_d_ECEarth_2C_s16r09_2064_world.nc') ds_temp = xr.open_mfdataset('/nobackup_3/users/stoop/7A_weather_data/tas_d_ECEarth_2C_s16r09_2064_world.nc') # In[3]: #%% Asignment of dimensions (GeoViews can use Iris cubes, Xarray data or just Numpy data) # Set the key dims (coordinates), the ones that are not part of the image will be sliders kdims = ['time', 'lat', 'lon'] # Load the GeoViews dataset (data, key dimensions, variable dimensions, projection) gv_psl= gv.Dataset(ds_psl, kdims=kdims, vdims='psl', crs=crs.PlateCarree()) gv_rsds= gv.Dataset(ds_rsds, kdims=kdims, vdims='rsds', crs=crs.PlateCarree()) gv_wind= gv.Dataset(ds_wind, kdims=kdims, vdims='sfcwind', crs=crs.PlateCarree()) gv_temp= gv.Dataset(ds_temp, kdims=kdims, vdims='tas', crs=crs.PlateCarree()) # In[4]: # Make an image of the data gv_temp.to.image(['lon','lat']) # # Changing figure characteristics # In[5]:
def plot_ly(lon, lat, alt, time, power, density, weight, bins, file_path, clear_fig, current_time_range, maps): '''Plotting routine to view raw data. Select map=False or True to view a 3 panel or single panel plot of the raw lma data. All other kwargs are used to display specific user selected traits of the data, e.g. raw source locations, gridded source count densities, etc. ''' fig = make_subplots( rows=5, cols=4, shared_xaxes=True, shared_yaxes=True, specs=[[{ 'colspan': 3, "rowspan": 2 }, None, {}, {}], [None, None, None, None], [{ 'colspan': 3, "rowspan": 3 }, {}, {}, { "rowspan": 3 }], [None, None, None, None], [None, None, None, None]], # print_grid=True ) fig.update_layout(autosize=False, width=1000, height=900) if maps == True: if clear_fig == 'No Data Found': print('Nope') if density == 'Points' or density == 'Density': if weight is not None: fig.add_trace(go.Scatter(x=[0, 0, 0], y=[0, 0, 0]), row=1, col=1) fig.add_trace(go.Scatter(x=[0, 0, 0], y=[0, 0, 0]), row=3, col=4) fig.add_trace(go.Scatter(x=[0, 0, 0], y=[0, 0, 0]), row=3, col=1) else: if density == 'Points': print('Picked Points') fig.add_trace(go.Scatter(x=[0, 0, 0], y=[0, 0, 0]), row=1, col=1) fig.add_trace(go.Scatter(x=[0, 0, 0], y=[0, 0, 0]), row=3, col=4) fig.add_trace(go.Scatter(x=[0, 0, 0], y=[0, 0, 0]), row=3, col=1) if weight == 'None': fig.update_traces(go.Scatter( x=lon, y=alt, mode='markers', ), row=1, col=1) fig.update_traces(go.Scatter( x=lon, y=lat, mode='markers', ), row=3, col=1) fig.update_traces(go.Scatter( x=alt, y=lat, mode='markers', ), row=3, col=4) else: if weight == 'alt': weight = alt / 1e4 cmap = cm.cm.deep_r elif weight == 'time': weight = time / 1e9 cmap = plt.cm.magma elif weight == 'power': weight = power * 3e1 cmap = cm.cm.algae_r fig.update_traces(go.Scatter(x=lon, y=alt, mode='markers', marker=dict(size=weight, color='black')), row=1, col=1) fig.update_traces(go.Scatter(x=lon, y=lat, mode='markers', marker=dict(size=weight, color='black')), row=3, col=1) fig.update_traces(go.Scatter(x=alt, y=lat, mode='markers', marker=dict(size=weight, color='black')), row=3, col=4) else: h0xy, xe1, ye1 = np.histogram2d(lon, lat, bins=(int(bins), int(bins))) h0xz, xe2, ye2 = np.histogram2d(lon, alt, bins=(int(bins), int(bins))) h0yz, xe3, ye3 = np.histogram2d(alt, lat, bins=(int(bins), int(bins))) colors = fig.add_trace(go.Heatmap(z=h0xy.T, showscale=True, coloraxis='coloraxis'), row=3, col=1) fig.add_trace(go.Heatmap(z=h0xz.T, coloraxis='coloraxis'), row=1, col=1) fig.add_trace(go.Heatmap(z=h0yz.T, coloraxis='coloraxis'), row=3, col=4) if weight == 'None': cbar_title = r'LMA Sources per square km' fig.update_traces(go.Heatmap(x=xe1, y=ye1, z=np.log10(h0xy).T, showscale=True, coloraxis='coloraxis'), row=3, col=1) fig.update_traces(go.Heatmap(x=xe2, y=ye2, z=np.log10(h0xz).T, coloraxis='coloraxis'), row=1, col=1) fig.update_traces(go.Heatmap(x=xe3, y=ye3, z=np.log10(h0yz).T, coloraxis='coloraxis'), row=3, col=4) color_bar_pref = dict( title=cbar_title, thicknessmode="pixels", thickness=40, lenmode="pixels", len=600, yanchor="bottom", y=0.05, ) fig.update_layout(coloraxis_colorbar=color_bar_pref, coloraxis={'colorscale': 'viridis'}) else: if weight == 'alt': cbar_title = 'LMA Source Altitude' weight = alt cmap = cm.cm.deep_r elif weight == 'time': cbar_title = 'LMA Source Time' weight = time cmap = plt.cm.magma elif weight == 'power': cbar_title = 'LMA Source Power' weight = power cmap = cm.cm.algae_r h0xy0, xe1, ye1 = np.histogram2d(lon, lat, bins=(int(bins), int(bins)), weights=weight) h0xz0, xe2, ye2 = np.histogram2d(lon, alt, bins=(int(bins), int(bins)), weights=weight) h0yz0, xe3, ye3 = np.histogram2d(alt, lat, bins=(int(bins), int(bins)), weights=weight) fig.update_traces(go.Heatmap(x=xe1, y=ye1, z=(h0xy0 / h0xy).T, showscale=True, coloraxis='coloraxis'), row=3, col=1) fig.update_traces(go.Heatmap(x=xe2, y=ye2, z=(h0xz0 / h0xz).T, coloraxis='coloraxis'), row=1, col=1) fig.update_traces(go.Heatmap(x=xe3, y=ye3, z=(h0yz0 / h0yz).T, coloraxis='coloraxis'), row=3, col=4) color_bar_pref = dict( title=cbar_title, thicknessmode="pixels", thickness=40, lenmode="pixels", len=600, yanchor="bottom", y=0.05, ) fig.update_layout(coloraxis_colorbar=color_bar_pref, coloraxis={'colorscale': 'viridis'}) fig.update_layout(showlegend=False, title_text=r"Date: {0}-{1}-{2} {3}".format( file_path.year, file_path.month, file_path.day, current_time_range)) fig.update_xaxes(matches='x', row=1, col=1) fig.update_xaxes(matches='x', row=3, col=1) fig.update_yaxes(matches='y2', row=3, col=1) fig.update_yaxes(matches='y2', row=3, col=4) fig.update_yaxes(matches='y', row=1, col=1) fig.update_xaxes(matches='y', row=3, col=4) responsive = pn.pane.Plotly(fig, config={'responsive': True}) else: #Original use of Plotl's MapBox #fig.add_trace(go.Densitymapbox(lon=lon, lat=lat, # radius=20)) #fig.update_layout(mapbox_style="carto-positron",mapbox_center_lon=-101.5,mapbox_center_lat=34,mapbox=dict(zoom=6)) #fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0}) #Switch to Holoviews for consistency: raw_hist, xe, ye = np.histogram2d(lon, lat, bins=(int(bins), int(bins))) # get xarray dataset, suited for handling raster data in pyviz xr_dataset = gv.Dataset( hv.Image( (xe, ye, np.log10(np.ma.MaskedArray(raw_hist.T, mask=raw_hist.T == 0))), bounds=(xe.min(), ye.min(), xe.max(), ye.max()), kdims=[hv.Dimension('x'), hv.Dimension('y')], datatype=['grid'])) # create contours from image gv.FilledContours(xr_dataset) fig = gv.tile_sources.Wikipedia.opts( width=900, height=900) * xr_dataset.to.image(['x', 'y']).opts( cmap='cubehelix', alpha=0.8 ) #gv.FilledContours(xr_dataset).opts(cmap='viridis', alpha=0.5) responsive = pn.pane.HoloViews(fig, config={'responsive': True}) return (responsive)