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 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 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)
"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
if year > end:
year = start
slider.value = year
import xarray as xr
import geoviews as gv
import geoviews.feature as gf
import xarray as xr
from cartopy import crs
gv.extension('bokeh', 'matplotlib')
# prepare some data
xarr = xr.open_dataset(
'/Users/doutriaux1/miniconda3/envs/jupyter-vcdat/share/cdat/sample_data/clt.nc',
decode_times=False).load()
xarr = xarr["clt"][0]
kdims = ['longitude', 'latitude']
vdims = ['clt']
dataset = gv.Dataset(xarr, kdims=kdims, vdims=vdims)
# ensemble = dataset.to(gv.Image, ['longitude', 'latitude'])
# gv.output(ensemble.opts(cmap='viridis', colorbar=True, fig_size=200, backend='matplotlib') * gf.coastline(),
# backend='matplotlib')
for backend in ["bokeh", "matplotlib"]:
print("RENDERING WITH:", backend)
img = gv.Image(dataset).opts(cmap="viridis",
backend=backend) * gf.coastline()
gv.save(img,
filename="plot_clt_geoviews_{}.png".format(backend),
backend=backend)
def load_image(time, p):
print("time %s, p %s" % (time, p))
data = dataset[p][3]
if not sea_data:
data = data[0]
img = gv.operation.project_image(gv.Image(data))
return img
# image_stack = hv.DynamicMap(load_image, kdims=['time', 'p'], streams=[Param()])
#plot = regrid(image_stack)# * gf.coastline(plot=dict(scale='10m')) #.redim.range(time=(0,3))
gf.coastline.set_param("extents", (90, -18, 154, 30))
coastline = gf.coastline(plot=dict(scale='50m'))
#regridded_map = regrid(load_image(0, params[0]))
data_map = hv.DynamicMap(load_image, streams=[Param()])
regridded_map = regrid(data_map)
print("coastline: %s, regridded_map %s" % (coastline, regridded_map))
plot = regridded_map * coastline
print("plot: %s" % (plot))
print(plot.id)
def select_param(param=params[0]):
data_map.event(p=param)
def select_param_handler(index):
def gen_plot():
infos = dsTable.get_plot_infos()
if infos is None:
return
ds, var_name, shape = infos
ds_uri = ds["id"]
timestamp = ds["data"]["time"][0]
file_name = ds_uri.split("/")[-1]
kdims = shape
vdims = [var_name]
lon_key, lat_key = None, None
for key in dsTable.meta_variables:
entry = dsTable.meta_variables[key]
if "attributes" not in entry or "standard_name" not in entry[
"attributes"]:
continue
if entry["attributes"]["standard_name"]["value"] == "longitude":
lon_key = key
if entry["attributes"]["standard_name"]["value"] == "latitude":
lat_key = key
if lat_key not in kdims or lon_key not in kdims:
log("'lat' and 'lon' are required dimensions!")
return
full_url = index["opendap_url"] + ds_uri
log("Opening dataset: " + full_url)
btn_plot_lonXlat.disabled = True
try:
print("Opening : " + full_url)
dataset = xr.open_dataset(full_url)
log("Dataset successfully opened. Loading data...")
kdimsSingularValue = list(
filter(lambda dim: dataset[dim].size == 1, kdims))
kdimsMultipleValues = list(
filter(lambda dim: dataset[dim].size > 1, kdims))
indexers = {
key: dataset[key].values[0]
for key in kdimsSingularValue
}
print(indexers)
dataset = dataset.sel(indexers=indexers)
print(kdimsMultipleValues, kdimsSingularValue)
xr_dataset = gv.Dataset(
dataset[var_name],
group=dsTable.to_long_name(var_name, True) + " ",
crs=ccrs.PlateCarree())
image = xr_dataset.to(gv.Image, [lon_key, lat_key], dynamic=True)
graph = image.options(colorbar=True,
tools=['hover'],
cmap="viridis",
width=800,
height=640,
colorbar_position="right",
toolbar="below") * gf.coastline()
renderer = hv.renderer('bokeh')
hover = HoverTool(
tooltips=[
("(x,y)", "(@lon{%0.1f}, @lat{%0.1f})"),
('desc', '@' + var_name),
],
formatters={
'y': 'printf', # use 'datetime' formatter for 'date' field
'x':
'printf', # use 'printf' formatter for 'adj close' field
# use default 'numeral' formatter for other fields
})
plot = renderer.get_plot(graph)
if len(kdimsMultipleValues) > 2:
# callback_policy="mouseup" for slider in plots
print(plot)
plot = renderer.get_widget(plot, "server")
bokeh_layout = plot.init_layout()
print(bokeh_layout)
latFull = dsTable.meta_variables[lat_key]["attributes"][
"standard_name"]["value"]
lonFull = dsTable.meta_variables[lon_key]["attributes"][
"standard_name"]["value"]
bk_plot = bokeh_layout.children[0]
#bk_plot.add_tools(hover)
bk_slider = bokeh_layout.children[1].children[1]
print(bk_slider.callback_policy)
bk_slider.callback_policy = "mouseup"
bk_plot.xaxis.axis_label = lonFull
bk_plot.yaxis.axis_label = latFull
print(lonFull, latFull)
# bk_plot.xaxis[0].formatter = NumeralTickFormatter(format="0.0")
# bk_plot.yaxis[0].formatter = NumeralTickFormatter(format="$0")
else:
bokeh_layout = plot.state
tab = Panel(title=timestamp, child=bokeh_layout)
plotTabs.tabs.append(tab)
log("Data successfully loaded!")
except Exception as e:
log("Failed to open or process dataset: %s" % full_url, e)
finally:
btn_plot_lonXlat.disabled = False