def view_eep_fit(self, mass, feh, plot_fit=True, order=5, p0=None, plot_p0=False):
import holoviews as hv
hv.extension('bokeh')
subdf = self.df.xs((mass, feh), level=('initial_mass', 'initial_feh'))
ds = hv.Dataset(subdf)
pts = hv.Points(ds, kdims=['age', 'eep'], vdims=['phase', 'interpolated']).options(tools=['hover'], width=800, height=400, marker='+')
primary_eeps = self.primary_eeps
primary_ages = [subdf.loc[e].age for e in primary_eeps if e < subdf.eep.max()]
from isochrones.eep import eep_fn, eep_jac, eep_fn_p0
from scipy.optimize import curve_fit
if p0 is None:
p0 = eep_fn_p0(subdf.age.values, subdf.eep.values, order=order)
m = subdf.eep < 808
if plot_fit:
pfit, _ = curve_fit(partial(eep_fn, order=order), subdf.age.values[m], subdf.eep.values[m], p0, jac=partial(eep_jac, order=order))
fit = hv.Points([(a, eep_fn(a, *pfit)) for a in subdf.age])
if plot_p0:
p0_fit = hv.Points([(a, eep_fn(a, *p0)) for a in subdf.age])
olay = pts * hv.Points([(a, e) for a, e in zip(primary_ages, primary_eeps)]).options(size=8)
if plot_fit:
olay = olay * fit
if plot_p0:
olay = olay * p0_fit
return olay
__all__ = [
'KELVIN', 'CrankNicolsonSolver', 'four_minutes_a_side', 'every_15_secs',
'sear_then_cook_low', 'sous_vide_liquid_nitrogen', 'slow_roast', 'hv',
'np', 'cook_recipe', 'snapshots_to_protein_state', 'PROTEIN_STATES'
]
import holoviews as hv
hv.extension('bokeh', logo=False)
import numpy as np
from enum import Enum
KELVIN = 273.15
class BC(Enum):
"""A class for holding boundary conditions."""
HEATING_LEFT = 0
HEATING_RIGHT = 1
HEATING_BOTH = 2
NO_HEATING = 3
def assemble_A_matrix(N, D, dx, dt, boundary_condition):
sigma = D * dt / (2 * dx**2)
A = np.zeros((N + 1, N + 1))
for i in range(N + 1):
if i == 0:
# imposed temperature
if boundary_condition == BC.HEATING_LEFT or boundary_condition == BC.HEATING_BOTH:
A[i, i] = 1
def init_renderer():
hv.extension('matplotlib')
hv.output(backend='matplotlib')
pyplot.switch_backend(RENDERER_NAME)
from holoviews.streams import Derived, History
from holoviews.plotting.plotly.callbacks import (
Selection1DCallback, RangeXYCallback, RangeXCallback, RangeYCallback,
BoundsXYCallback, BoundsXCallback, BoundsYCallback)
# Dash imports
import dash_core_components as dcc
import dash_html_components as html
from dash import callback_context
from dash.dependencies import Output, Input, State
# plotly.py imports
import plotly.graph_objects as go
# Activate plotly as current HoloViews extension
hv.extension("plotly")
# Named tuples definitions
StreamCallback = namedtuple("StreamCallback", ["input_ids", "fn", "output_id"])
DashComponents = namedtuple("DashComponents",
["graphs", "kdims", "store", "resets", "children"])
HoloViewsFunctionSpec = namedtuple("HoloViewsFunctionSpec",
["fn", "kdims", "streams"])
def get_layout_ranges(plot):
layout_ranges = {}
fig_dict = plot.state
for k in fig_dict['layout']:
if k.startswith('xaxis') or k.startswith('yaxis'):
if "range" in fig_dict['layout'][k]:
## preliminaries ##
import holoviews as hv
import hvplot.pandas
import numpy as np
import pandas as pd
import panel as pn
from holoviews.operation.datashader import rasterize, shade
from holoviews.selection import link_selections
from holoviews.util.transform import dim
hv.extension("bokeh", width=100)
pn.extension(comms="vscode")
## create random walks (one location) ##
data_df = pd.DataFrame()
npoints = 15000
np.random.seed(71)
x = np.arange(npoints)
y1 = 1300 + 2.5 * np.random.randn(npoints).cumsum()
y2 = 1500 + 2 * np.random.randn(npoints).cumsum()
y3 = 3 + np.random.randn(npoints).cumsum()
data_df.loc[:, "x"] = x
data_df.loc[:, "rand1"] = y1
data_df.loc[:, "rand2"] = y2
data_df.loc[:, "rand3"] = y3
colors = hv.Cycle("Category10").values
dims = ["rand1", "rand2", "rand3"]
items = []
for c, dim in zip(colors, dims):
def plot_infection_rates_by_contact_models(
df_or_time_series: Union[pd.DataFrame, dd.core.DataFrame],
show_reported_cases: bool = False,
unit: str = "share",
fig_kwargs: Optional[Dict[str, Any]] = None,
) -> hv.HeatMap:
"""Plot infection rates by contact models.
Parameters
----------
df_or_time_series : Union[pandas.DataFrame, dask.dataframe.core.DataFrame]
The input can be one of the following two.
1. It is a :class:`dask.dataframe.core.DataFrame` which holds the time series
from a simulation.
2. It can be a :class:`pandas.DataFrame` which is created with
:func:`prepare_data_for_infection_rates_by_contact_models`. It allows to
compute the data for various simulations with different seeds and use the
average over all seeds.
show_reported_cases : bool, optional
A boolean to select between reported or real cases of infections. Reported cases
are identified via testing mechanisms.
unit : str
The arguments specifies the unit shown in the figure.
- ``"share"`` means that daily units represent the share of infection caused
by a contact model among all infections on the same day.
- ``"population_share"`` means that daily units represent the share of
infection caused by a contact model among all people on the same day.
- ``"incidence"`` means that the daily units represent incidence levels per
100,000 individuals.
fig_kwargs : Optional[Dict[str, Any]], optional
Additional keyword arguments which are passed to ``heatmap.opts`` to style the
plot. The keyword arguments overwrite or extend the default arguments.
Returns
-------
heatmap : hv.HeatMap
The heatmap object.
"""
fig_kwargs = (DEFAULT_IR_PER_CM_KWARGS if fig_kwargs is None else {
**DEFAULT_IR_PER_CM_KWARGS,
**fig_kwargs
})
if _is_data_prepared_for_heatmap(df_or_time_series):
df = df_or_time_series
else:
df = prepare_data_for_infection_rates_by_contact_models(
df_or_time_series, show_reported_cases, unit)
hv.extension("bokeh", logo=False)
heatmap = hv.HeatMap(df)
plot = heatmap.opts(**fig_kwargs)
return plot
def interactive(
umap_object,
labels=None,
values=None,
hover_data=None,
theme=None,
cmap="Blues",
color_key=None,
color_key_cmap="Spectral",
background="white",
width=800,
height=800,
point_size=None,
subset_points=None,
):
"""Create an interactive bokeh plot of a UMAP embedding.
While static plots are useful, sometimes a plot that
supports interactive zooming, and hover tooltips for
individual points is much more desireable. This function
provides a simple interface for creating such plots. The
result is a bokeh plot that will be displayed in a notebook.
Note that more complex tooltips etc. will require custom
code -- this is merely meant to provide fast and easy
access to interactive plotting.
Parameters
----------
umap_object: trained UMAP object
A trained UMAP object that has a 2D embedding.
labels: array, shape (n_samples,) (optional, default None)
An array of labels (assumed integer or categorical),
one for each data sample.
This will be used for coloring the points in
the plot according to their label. Note that
this option is mutually exclusive to the ``values``
option.
values: array, shape (n_samples,) (optional, default None)
An array of values (assumed float or continuous),
one for each sample.
This will be used for coloring the points in
the plot according to a colorscale associated
to the total range of values. Note that this
option is mutually exclusive to the ``labels``
option.
hover_data: DataFrame, shape (n_samples, n_tooltip_features)
(optional, default None)
A dataframe of tooltip data. Each column of the dataframe
should be a Series of length ``n_samples`` providing a value
for each data point. Column names will be used for
identifying information within the tooltip.
theme: string (optional, default None)
A color theme to use for plotting. A small set of
predefined themes are provided which have relatively
good aesthetics. Available themes are:
* 'blue'
* 'red'
* 'green'
* 'inferno'
* 'fire'
* 'viridis'
* 'darkblue'
* 'darkred'
* 'darkgreen'
cmap: string (optional, default 'Blues')
The name of a matplotlib colormap to use for coloring
or shading points. If no labels or values are passed
this will be used for shading points according to
density (largely only of relevance for very large
datasets). If values are passed this will be used for
shading according the value. Note that if theme
is passed then this value will be overridden by the
corresponding option of the theme.
color_key: dict or array, shape (n_categories) (optional, default None)
A way to assign colors to categoricals. This can either be
an explicit dict mapping labels to colors (as strings of form
'#RRGGBB'), or an array like object providing one color for
each distinct category being provided in ``labels``. Either
way this mapping will be used to color points according to
the label. Note that if theme
is passed then this value will be overridden by the
corresponding option of the theme.
color_key_cmap: string (optional, default 'Spectral')
The name of a matplotlib colormap to use for categorical coloring.
If an explicit ``color_key`` is not given a color mapping for
categories can be generated from the label list and selecting
a matching list of colors from the given colormap. Note
that if theme
is passed then this value will be overridden by the
corresponding option of the theme.
background: string (optional, default 'white')
The color of the background. Usually this will be either
'white' or 'black', but any color name will work. Ideally
one wants to match this appropriately to the colors being
used for points etc. This is one of the things that themes
handle for you. Note that if theme
is passed then this value will be overridden by the
corresponding option of the theme.
width: int (optional, default 800)
The desired width of the plot in pixels.
height: int (optional, default 800)
The desired height of the plot in pixels
point_size: int (optional, default None)
The size of each point marker
subset_points: array, shape (n_samples,) (optional, default None)
A way to select a subset of points based on an array of boolean
values.
Returns
-------
"""
if theme is not None:
cmap = _themes[theme]["cmap"]
color_key_cmap = _themes[theme]["color_key_cmap"]
background = _themes[theme]["background"]
if labels is not None and values is not None:
raise ValueError(
"Conflicting options; only one of labels or values should be set")
points = umap_object.embedding_
if subset_points is not None:
if len(subset_points) != points.shape[0]:
raise ValueError(
"Size of subset points ({}) does not match number of input points ({})"
.format(len(subset_points), points.shape[0]))
points = points[subset_points]
if points.shape[1] != 2:
raise ValueError(
"Plotting is currently only implemented for 2D embeddings")
if point_size is None:
point_size = 100.0 / np.sqrt(points.shape[0])
data = pd.DataFrame(umap_object.embedding_, columns=("x", "y"))
if labels is not None:
data["label"] = labels
if color_key is None:
unique_labels = np.unique(labels)
num_labels = unique_labels.shape[0]
color_key = _to_hex(
plt.get_cmap(color_key_cmap)(np.linspace(0, 1, num_labels)))
if isinstance(color_key, dict):
data["color"] = pd.Series(labels).map(color_key)
else:
unique_labels = np.unique(labels)
if len(color_key) < unique_labels.shape[0]:
raise ValueError(
"Color key must have enough colors for the number of labels"
)
new_color_key = {
k: color_key[i]
for i, k in enumerate(unique_labels)
}
data["color"] = pd.Series(labels).map(new_color_key)
colors = "color"
elif values is not None:
data["value"] = values
palette = _to_hex(plt.get_cmap(cmap)(np.linspace(0, 1, 256)))
colors = btr.linear_cmap("value",
palette,
low=np.min(values),
high=np.max(values))
else:
colors = matplotlib.colors.rgb2hex(plt.get_cmap(cmap)(0.5))
if subset_points is not None:
data = data[subset_points]
if hover_data is not None:
hover_data = hover_data[subset_points]
if points.shape[0] <= width * height // 10:
if hover_data is not None:
tooltip_dict = {}
for col_name in hover_data:
data[col_name] = hover_data[col_name]
tooltip_dict[col_name] = "@" + col_name
tooltips = list(tooltip_dict.items())
else:
tooltips = None
# bpl.output_notebook(hide_banner=True) # this doesn't work for non-notebook use
data_source = bpl.ColumnDataSource(data)
plot = bpl.figure(
width=width,
height=height,
tooltips=tooltips,
background_fill_color=background,
)
plot.circle(x="x",
y="y",
source=data_source,
color=colors,
size=point_size)
plot.grid.visible = False
plot.axis.visible = False
# bpl.show(plot)
else:
if hover_data is not None:
warn("Too many points for hover data -- tooltips will not"
"be displayed. Sorry; try subssampling your data.")
hv.extension("bokeh")
hv.output(size=300)
hv.opts(
'RGB [bgcolor="{}", xaxis=None, yaxis=None]'.format(background))
if labels is not None:
point_plot = hv.Points(data, kdims=["x", "y"])
plot = hd.datashade(
point_plot,
aggregator=ds.count_cat("color"),
color_key=color_key,
cmap=plt.get_cmap(cmap),
width=width,
height=height,
)
elif values is not None:
min_val = data.values.min()
val_range = data.values.max() - min_val
data["val_cat"] = pd.Categorical(
(data.values - min_val) // (val_range // 256))
point_plot = hv.Points(data, kdims=["x", "y"], vdims=["val_cat"])
plot = hd.datashade(
point_plot,
aggregator=ds.count_cat("val_cat"),
cmap=plt.get_cmap(cmap),
width=width,
height=height,
)
else:
point_plot = hv.Points(data, kdims=["x", "y"])
plot = hd.datashade(
point_plot,
aggregator=ds.count(),
cmap=plt.get_cmap(cmap),
width=width,
height=height,
)
return plot
def sankey_plot_main():
config_params(font_size=4)
hv.extension('matplotlib')
hv.output(fig='svg')
forbidden = ['RADIATION', 'Miscellanious', 'Unknown', 'TopoII', 'TOPOII']
out, dic_t = create_matrix_treatments_plot()
order_ttypes = [
'Breast',
'Colon-Rectum',
'Prostate',
'Lung',
'Skin',
'Bone-Soft-tissue',
'Ovary',
'Esophagus',
'Urinary-tract',
'NET',
'Kidney',
'Nervous-system',
'Biliary',
'Pancreas',
'Unknown',
'Uterus',
'Head-and-neck',
'Liver',
'Stomach',
'Mesothelioma',
]
all_rows = []
for ttype in order_ttypes:
samples = dic_t[ttype]
subs = out.loc[samples]
for col in subs:
if col not in forbidden:
all_rows.append((ttype, col, int(subs[col].sum())))
matrix_df = pd.DataFrame(all_rows)
matrix_df.columns = ['target', 'source', 'value']
matrix_df = matrix_df[(matrix_df['target'] != 'Unknown')]
matrix_df = matrix_df.fillna(0)
matrix_df['value'] = matrix_df['value'].astype(int)
good_source = set()
for source, data in matrix_df.groupby(by='source'):
tot = data['value'].sum()
if tot > 30:
if source != 'Unknown':
good_source.add(source)
matrix_df = matrix_df[matrix_df['source'].isin(good_source)]
out = hv.Sankey(matrix_df.sort_values(
by='source',
ascending=True,
),
label='').opts(label_position='left',
edge_color='target',
node_color='index',
cmap='Set1') # color=total_colors)
fig = hv.render(out)
fig.set_figwidth(10)
fig.savefig('figures/2A.svg')
fig.savefig('figures/2A.png', dpi=600)
def show_time_range(st, run_id, t0, dt=10):
from functools import partial
import numpy as np
import pandas as pd
import holoviews as hv
from holoviews.operation.datashader import datashade, dynspread
hv.extension('bokeh')
import strax
import gc
# Somebody thought it was a good idea to call gc.collect explicitly somewhere in holoviews
# This makes dynamic PMT maps super slow
# Until I trace the offender:
gc.collect = lambda *args, **kwargs: None
# Custom wheel zoom tool that only zooms in time
from bokeh.models import WheelZoomTool
time_zoom = WheelZoomTool(dimensions='width')
# Get ADC->pe multiplicative conversion factor
from pax.configuration import load_configuration
from pax.dsputils import adc_to_pe
pax_config = load_configuration('XENON1T')["DEFAULT"]
to_pe = np.array(
[adc_to_pe(pax_config, ch) for ch in range(pax_config['n_channels'])])
tpc_r = pax_config['tpc_radius']
# Get locations of PMTs
r = []
for q in pax_config['pmts']:
r.append(
dict(x=q['position']['x'],
y=q['position']['y'],
i=q['pmt_position'],
array=q.get('array', 'other')))
f = 1.08
pmt_locs = pd.DataFrame(r)
records = st.get_array(run_id,
'raw_records',
time_range=(t0, t0 + int(1e10)))
# TOOD: don't reprocess, just load...
hits = strax.find_hits(records)
peaks = strax.find_peaks(hits,
to_pe,
gap_threshold=300,
min_hits=3,
result_dtype=strax.peak_dtype(n_channels=260))
strax.sum_waveform(peaks, records, to_pe)
# Integral in pe
areas = records['data'].sum(axis=1) * to_pe[records['channel']]
def normalize_time(t):
return (t - records[0]['time']) / 1e9
# Create dataframe with record metadata
df = pd.DataFrame(
dict(area=areas,
time=normalize_time(records['time']),
channel=records['channel']))
# Convert to holoviews Points
points = hv.Points(
df,
kdims=[
hv.Dimension('time', label='Time', unit='sec'),
hv.Dimension('channel', label='PMT number', range=(0, 260))
],
vdims=[
hv.Dimension(
'area',
label='Area',
unit='pe',
# range=(0, 1000)
)
])
def pmt_map(t_0, t_1, array='top', **kwargs):
# Compute the PMT pattern (fast)
ps = points[(t_0 <= points['time']) & (points['time'] < t_1)]
areas = np.bincount(ps['channel'],
weights=ps['area'],
minlength=len(pmt_locs))
# Which PMTs should we include?
pmt_mask = pmt_locs['array'] == array
d = pmt_locs[pmt_mask].copy()
d['area'] = areas[pmt_mask]
# Convert to holoviews points
d = hv.Dataset(d,
kdims=[
hv.Dimension('x',
unit='cm',
range=(-tpc_r * f, tpc_r * f)),
hv.Dimension('y',
unit='cm',
range=(-tpc_r * f, tpc_r * f)),
hv.Dimension('i', label='PMT number'),
hv.Dimension('area', label='Area', unit='PE')
])
return d.to(hv.Points,
vdims=['area', 'i'],
group='PMTPattern',
label=array.capitalize(),
**kwargs).opts(plot=dict(color_index=2,
tools=['hover'],
show_grid=False),
style=dict(size=17, cmap='magma'))
def pmt_map_range(x_range, array='top', **kwargs):
# For use in dynamicmap with streams
if x_range is None:
x_range = (0, 0)
return pmt_map(x_range[0], x_range[1], array=array, **kwargs)
xrange_stream = hv.streams.RangeX(source=points)
# TODO: weigh by area
def channel_map():
return dynspread(
datashade(
points, y_range=(0, 260),
streams=[xrange_stream])).opts(plot=dict(
width=600,
tools=[time_zoom, 'xpan'],
default_tools=['save', 'pan', 'box_zoom', 'save', 'reset'],
show_grid=False))
def plot_peak(p):
# It's better to plot amplitude /time than per bin, since
# sampling times are now variable
y = p['data'][:p['length']] / p['dt']
t_edges = np.arange(p['length'] + 1, dtype=np.int64)
t_edges = t_edges * p['dt'] + p['time']
t_edges = normalize_time(t_edges)
# Correct step plotting from Knut
t_ = np.zeros(2 * len(y))
y_ = np.zeros(2 * len(y))
t_[0::2] = t_edges[0:-1]
t_[1::2] = t_edges[1::]
y_[0::2] = y
y_[1::2] = y
c = hv.Curve(dict(time=t_, amplitude=y_),
kdims=points.kdims[0],
vdims=hv.Dimension('amplitude',
label='Amplitude',
unit='PE/ns'),
group='PeakSumWaveform')
return c.opts(
plot=dict( # interpolation='steps-mid',
# default_tools=['save', 'pan', 'box_zoom', 'save', 'reset'],
# tools=[time_zoom, 'xpan'],
width=600,
shared_axes=False,
show_grid=True),
style=dict(color='b')
# norm=dict(framewise=True)
)
def peaks_in(t_0, t_1):
return peaks[(normalize_time(peaks['time'] +
peaks['length'] * peaks['dt']) > t_0)
& (normalize_time(peaks['time']) < t_1)]
def plot_peaks(t_0, t_1, n_max=10):
# Find peaks in this range
ps = peaks_in(t_0, t_1)
# Show only the largest n_max peaks
if len(ps) > n_max:
areas = ps['area']
max_area = np.sort(areas)[-n_max]
ps = ps[areas >= max_area]
return hv.Overlay(items=[plot_peak(p) for p in ps])
def plot_peak_range(x_range, **kwargs):
# For use in dynamicmap with streams
if x_range is None:
x_range = (0, 10)
return plot_peaks(x_range[0], x_range[1], **kwargs)
top_map = hv.DynamicMap(partial(pmt_map_range, array='top'),
streams=[xrange_stream])
bot_map = hv.DynamicMap(partial(pmt_map_range, array='bottom'),
streams=[xrange_stream])
waveform = hv.DynamicMap(plot_peak_range, streams=[xrange_stream])
layout = waveform + top_map + channel_map() + bot_map
return layout.cols(2)
# Geoviews needs to be loaded as well (quite heavy to load if not used)
import geoviews as gv
# Features are often used, shortcut is handy
import geoviews.feature as gf
# The packages is based on Xarray, so this is kinda handy
import xarray as xr
# Cartopy is used to make the maps
from cartopy import crs
# There is a tab-completion issue, but that can be fixed
hv.extension(case_sensitive_completion=True)
# Holoviews uses an ~/.holoviews.rc file at start-up, this line can be placed there
# In[2]:
#%% Loading some data (Multi-File data loading is used here as an example)
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]:
# -*- coding: utf-8 -*-
# !/usr/bin/env python
# Importing libraries
import holoviews as hv
from holoviews import opts, dim
import pandas as pd
import numpy as np
hv.extension("matplotlib")
hv.output(fig='pdf', size=250)
def chord_diagram(df_flow_MN, n_cycles, dir_path):
'''
Function to plot chord diagram for flows across industry sectors
'''
df_flow_MN = df_flow_MN.loc[df_flow_MN['Option'] == 'Industrial']
df_flow_MN = df_flow_MN[['Cycle', 'Generator Industry Sector',
'Flow transferred', 'RETDF Industry Sector',
'Recycled flow', 'Industry sector']]
Flows = {'waste': {'Generator Industry Sector': 'source',
'RETDF Industry Sector': 'target',
'Flow transferred': 'value'},
'recyled': {'RETDF Industry Sector': 'source',
'Industry sector': 'target',
'Recycled flow': 'value'}}
df_links = pd.DataFrame()
for Flow, Link in Flows.items():
This example uses the *Iris* dataset.
"""
from typing import Any, Dict, Tuple
import holoviews as hv
import panel as pn
import param
import plotly.io as pio
from holoviews import opts
from panel.template import FastGridTemplate
from plotly.data import iris
from application.config import site
hv.extension("bokeh", "plotly")
APPLICATION = site.create_application(
url="holoviews-linked-brushing",
name="HoloViews Linked Brushing",
author="Marc Skov Madsen",
introduction=
"A demonstration of HoloViews linked brushing for Bokeh and Plotly backends",
description=__doc__,
thumbnail_url="holoviews-linked-brushing.png",
code_url="holoviews_linked_brushing.py",
mp4_url="holoviews-linked-brushing.mp4",
tags=[
"Panel", "Bokeh", "Plotly", "HoloViews", "Linked Brushing",
"Cross Filter"
],
def chord_diagram(ds, agg='mean', minimum_quantile=0,
groups=None, size=200, pallette='Category20',
fig_inches=4):
"""
Build a chord diagram on the base of holoviews [1].
It visualizes allocated peer-to-peer flows for all buses given in
the data. As for compatibility with ipython shell the rendering of
the image is passed to matplotlib however to the disfavour of
interactivity. Note that the plot becomes only meaningful for networks
with N > 5, because of sparse flows otherwise.
[1] http://holoviews.org/reference/elements/bokeh/Chord.html
Parameters
----------
allocation : xarray.Dataset
Dataset with 'peer_to_peer' variable.
lower_bound : int, default is 0
filter small power flows by a lower bound
groups : pd.Series, default is None
Specify the groups of your buses, which are then used for coloring.
The series must contain values for all allocated buses.
size : int, default is 300
Set the size of the holoview figure
save_path : str, default is '/tmp/chord_diagram_pypsa'
set the saving path of your figure
"""
from holoviews.plotting.mpl import Layout, LayoutPlot
import holoviews as hv
hv.extension('matplotlib')
allocation = filter_null(
as_dense(
ds.peer_to_peer.mean('snapshot')),
'source') .to_series().dropna()
if groups is not None:
allocation = allocation.rename(groups).sum(level=['sink', 'source'])
allocated_buses = allocation.index.levels[0] \
.append(allocation.index.levels[1]).unique()
bus_map = pd.Series(range(len(allocated_buses)), index=allocated_buses)
links = allocation.to_frame('value').reset_index() .replace(
{
'source': bus_map,
'sink': bus_map}) .sort_values('source').reset_index(
drop=True)[
lambda df: df.value >= df.value.quantile(minimum_quantile)]
nodes = pd.DataFrame({'bus': bus_map.index})
cindex = 'index'
ecindex = 'source'
nodes = hv.Dataset(nodes, 'index')
diagram = hv.Chord((links, nodes))
diagram = diagram.opts(style={'cmap': pallette,
'edge_cmap': pallette,
'tight': True},
plot={'label_index': 'bus',
'color_index': cindex,
'edge_color_index': ecindex})
# fig = hv.render(diagram, size=size, dpi=300)
fig = LayoutPlot(Layout([diagram]), dpi=300, fig_size=size,
fig_inches=fig_inches,
tight=True, tight_padding=0,
fig_bounds=(-.15, -.15, 1.15, 1.15),
hspace=0, vspace=0, fontsize=15)\
.initialize_plot()
return fig, fig.axes
import dask.dataframe as dd
import holoviews as hv
import geoviews as gv
from bokeh.models import Slider, Button
from bokeh.layouts import layout
from bokeh.io import curdoc
from bokeh.models import WMTSTileSource
from holoviews.operation.datashader import datashade, aggregate, shade
from holoviews.plotting.util import fire
shade.cmap = fire
hv.extension('bokeh')
renderer = hv.renderer('bokeh').instance(mode='server')
# Load data
usecols = ['tpep_pickup_datetime', 'dropoff_x', 'dropoff_y']
ddf = dd.read_csv('../data/nyc_taxi.csv', parse_dates=['tpep_pickup_datetime'], usecols=usecols)
ddf['hour'] = ddf.tpep_pickup_datetime.dt.hour
ddf = ddf.persist()
from bokeh.models import WMTSTileSource
url = 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{Z}/{Y}/{X}.jpg'
wmts = gv.WMTS(WMTSTileSource(url=url))
stream = hv.streams.Stream.define('HourSelect', hour=0)()
points = hv.Points(ddf, kdims=['dropoff_x', 'dropoff_y'])
dmap = hv.util.Dynamic(points, operation=lambda obj, hour: obj.select(hour=hour),
streams=[stream])
def wrapped_f(context: strax.Context, run_id: str, **kwargs):
# Validate arguments
known_kwargs = (
'time_range seconds_range time_within time_selection '
'ignore_time_warning '
'selection_str t_reference to_pe config').split()
for k in kwargs:
if k not in known_kwargs and k not in parameters:
# Python itself also raises TypeError for invalid kwargs
raise TypeError(f"Unknown argument {k} for {f.__name__}")
if 'config' in kwargs:
context = context.new_context(config=kwargs['config'])
# Say magic words to enable holoviews
if hv_bokeh:
global _hv_bokeh_initialized
if not _hv_bokeh_initialized:
import holoviews
holoviews.extension('bokeh')
_hv_bokeh_initialized = True
# TODO: This is a placeholder until the corrections system
# is more fully developed
if 'to_pe' in parameters and 'to_pe' not in kwargs:
kwargs['to_pe'] = straxen.get_to_pe(
run_id, 'https://raw.githubusercontent.com/XENONnT/'
'strax_auxiliary_files/master/to_pe.npy')
# Prepare selection arguments
kwargs['time_range'] = context.to_absolute_time_range(
run_id,
targets=requires,
**{
k: kwargs.get(k)
for k in ('time_range seconds_range time_within'.split())
})
kwargs.setdefault('time_selection', default_time_selection)
kwargs.setdefault('selection_str', None)
kwargs['t_reference'] = context.estimate_run_start(
run_id, requires)
if warn_beyond_sec is not None and not kwargs.get(
'ignore_time_warning'):
tr = kwargs['time_range']
if tr is None:
sec_requested = float('inf')
else:
sec_requested = (tr[1] - tr[0]) / int(1e9)
if sec_requested > warn_beyond_sec:
tr_str = "the entire run" if tr is None else f"{sec_requested} seconds"
raise ValueError(
f"The author of this mini analysis recommends "
f"not requesting more than {warn_beyond_sec} seconds. "
f"You are requesting {tr_str}. If you wish to proceed, "
"pass ignore_time_warning = True.")
# Load required data, if any
if len(requires):
deps_by_kind = strax.group_by_kind(requires,
context=context,
require_time=False)
for dkind, dtypes in deps_by_kind.items():
if dkind in kwargs:
# Already have data, just apply cuts
kwargs[dkind] = context.apply_selection(
kwargs[dkind],
selection_str=kwargs['selection_str'],
time_range=kwargs['time_range'],
time_selection=kwargs['time_selection'])
else:
kwargs[dkind] = context.get_array(
run_id,
dtypes,
selection_str=kwargs['selection_str'],
time_range=kwargs['time_range'],
time_selection=kwargs['time_selection'],
# Arguments for new context, if needed
config=kwargs.get('config'),
register=kwargs.get('register'),
storage=kwargs.get('storage', tuple()))
# If user did not give time kwargs, but the function expects
# a time_range, try to add one based on the time range of the data
base_dkind = list(deps_by_kind.keys())[0]
x = kwargs[base_dkind]
if len(x) and kwargs.get('time_range') is None:
x0 = x.iloc[0] if isinstance(x, pd.DataFrame) else x[0]
try:
kwargs.setdefault('time_range',
(x0['time'], strax.endtime(x).max()))
except AttributeError:
# If x is a holoviews dataset, this will fail.
pass
if 'seconds_range' in parameters:
if kwargs.get('time_range') is None:
scr = None
else:
scr = tuple([(t - kwargs['t_reference']) / int(1e9)
for t in kwargs['time_range']])
kwargs.setdefault('seconds_range', scr)
kwargs.setdefault('run_id', run_id)
kwargs.setdefault('context', context)
if 'kwargs' in parameters:
# Likely this will be passed to another mini-analysis
to_pass = kwargs
# Do not pass time_range and seconds_range both (unless explicitly requested)
# strax does not like that
if 'seconds_range' in to_pass and not 'seconds_range' in parameters:
del to_pass['seconds_range']
if 'time_within' in to_pass and not 'time_within' in parameters:
del to_pass['time_within']
else:
# Pass only arguments the function wants
to_pass = {k: v for k, v in kwargs.items() if k in parameters}
return f(**to_pass)
def plot_stations(self):
"""
Returns
-------
"""
hv.extension('bokeh')
opts.defaults(opts.Overlay(active_tools=['wheel_zoom', 'pan']))
return (gf.ocean*gf.land*gf.ocean* gf.borders) *\
self.metadata.hvplot.points('longitude', 'latitude',
hover_cols=['id','name'],
grid=True, width=600, height=400,
project=True, alpha=0.8,
xlim=(-81, -74), ylim=(44, 49.2), tiles='EsriUSATopo')
# def get_metadata_stations(bucket,
# latlngbox,
# storage_options):
# df = dd.read_csv(bucket, storage_options=storage_options)
# return df[df['longitude'].between(latlngbox[0], latlngbox[1]) & df['latitude'].between(latlngbox[2],
# latlngbox[3])].compute()
#
#
# def get_metadata_stations_all(bucket,
# storage_options):
# return dd.read_csv(bucket, storage_options=storage_options)
#
#
# def get_data_stations(bucket,
# metadata_stations,
# element,
# storage_options):
# df = dd.read_csv(bucket, storage_options=storage_options)
# return df.loc[df.id.isin(metadata_stations.id) & df.element.isin(element)].compute()
#
#
# def crop_zone(df, latlngbox):
# gdf = gpd.GeoDataFrame(
# df, geometry=gpd.points_from_xy(x=df['Longitude (Decimal Degrees)'], y=df['Latitude (Decimal Degrees)'])
# )
# return gdf[gdf['Longitude (Decimal Degrees)'].between(latlngbox[0], latlngbox[1])
# & gdf['Latitude (Decimal Degrees)'].between(latlngbox[2], latlngbox[3])]
#
#
# def visualisation_stations(gdf, df_stations, latlngbox):
# chro = px.choropleth(gdf.reset_index().drop(columns=['geometry']),
# geojson=json.loads(gdf.to_json()), locations='index',
# hover_name="NOM",
# title='Bassin Outaouais',
# )
#
# sc = go.Scattergeo(
# lon = df_stations['longitude'],
# lat = df_stations['latitude'],
# text = df_stations['name'],
# mode = 'markers',
# marker_color ='red',
# name = 'Stations météo'
# )
#
# fig = go.Figure(data=[sc, chro.data[0]])
#
#
# fig.update_layout(
# title = 'Station météorologiques contenant des données de précipitations (PRCP)',
# geo = dict(
# showland = True,
# showsubunits = True,
# showcountries = True,
# resolution = 50,
# showlakes = True,
# lonaxis = dict(
# showgrid = True,
# gridwidth = 0.5,
# range= [ latlngbox[0] - 1, latlngbox[1] + 1],
# dtick = 5
# ),
# lataxis = dict (
# showgrid = True,
# gridwidth = 0.5,
# range= [ latlngbox[2] - 1, latlngbox[3] + 1],
# dtick = 5
# )
# )
# )
# return fig.show()
import numpy as np
import pandas as pd
import cartopy.crs as ccrs
from cartopy import crs
import geoviews as gv
import holoviews as hv
import geoviews.tile_sources as gts
import xarray as xr
import panel as pn
import os, sys, shutil, time, datetime
from collections import defaultdict
pn.extension()
gv.extension("bokeh", logo=False)
hv.extension("bokeh", logo=False)
hv.Dimension.type_formatters[np.datetime64] = '%Y-%m-%d'
gv.Dimension.type_formatters[np.datetime64] = '%Y-%m-%d'
#### Header Object #####
def make_header_html(header_html_path=None):
logo = "https://www.kyushu-u.ac.jp/img/common_en/logo.png"
title = '<p style="font-size:30px">Passive Seismic Monitoring System</p>'
# creator = 'Created by: Fernando Lawrens Hutapea, Takeshi Tsuji, and Tatsunori Ikeda <br>'
info = "(Ambient noise data is provided by National Research Institute for Earth Science and Disaster Prevention (NIED) Japan)"
creator = 'Presently the monitoring result is updated weekly (Saturday) <br> Please use Firefox or Google Chrome or Microsoft Edge <br>'
current = np.datetime64(datetime.datetime.now(), "s").astype(str)
last_update = "Last update: {} <br>".format(current) # today's date
header = pn.Row(
logo, pn.Spacer(width=30),
pn.Column(pn.Spacer(height=0), pn.Pane(title, height=16, width=900),
def plot_frames(data, backend='matplotlib', mode='mosaic', rows=1, vmax=None,
vmin=None, circle=None, circle_alpha=0.8, circle_color='white',
circle_linestyle='-', circle_radius=6, circle_label=False, circle_label_color='white',
arrow=None, arrow_alpha=0.8, arrow_length=10, arrow_shiftx=5,
arrow_label=None, label=None, label_pad=5, label_size=12,
label_color='white',grid=False, grid_alpha=0.4, grid_color='#f7f7f7',
grid_spacing=None, cross=None, cross_alpha=0.4, lab_fontsize=8,
cross_color='white', ang_scale=False, ang_ticksep=50, ndec=1,
pxscale=0.01, auscale=1., ang_legend=False, au_legend=False,
axis=True, show_center=False, cmap=None, log=False,
colorbar=True, colorbar_ticks=None, dpi=100, size_factor=6,
horsp=0.4, versp=0.2, width=400, height=400, title=None,
tit_size=16, sampling=1, save=None, transparent=False):
""" Plot a 2d array or a tuple of 2d arrays. Supports the ``matplotlib`` and
``bokeh`` backends. When having a tuple of 2d arrays, the plot turns into a
mosaic. For ``matplotlib``, instead of a mosaic of images, we can create a
mosaic of surface plots. Also, when using the ``matplotlib`` backend, this
function allows to annotate and customize the plot and produce publication
quality figures.
Parameters
----------
data : numpy.ndarray or tuple
A single 2d array or a tuple of 2d arrays.
backend : {'matplotlib', 'bokeh'}, str optional
Selects the backend used to display the plots. ``Matplotlib`` plots
are static and allow customization (leading to publication quality
figures). ``Bokeh`` plots are interactive, allowing the used to zoom,
pan, inspect pixel values, etc.
mode : {'mosaic', 'surface'}, str optional
[backend='matplotlib'] Controls whether to turn the images into surface
plots.
rows : int, optional
How many rows (subplots in a grid) in the case ``data`` is a tuple of
2d arrays.
vmax : None, float/int or tuple of float/int, optional
For defining the data range that the colormap covers. When set to None,
the colormap covers the complete value range of the supplied data.
vmin : None, float/int or tuple of float/int, optional
For stretching the displayed pixels values. When set to None,
the colormap covers the complete value range of the supplied data.
circle : None, tuple or tuple of tuples, optional
[backend='matplotlib'] To show a circle at the given px coordinates. The
circles are shown on all subplots.
circle_alpha : float or tuple of floats, optional
[backend='matplotlib'] Alpha transparency for each circle.
circle_color : str, optional
[backend='matplotlib'] Color of the circles. White by default.
circle_radius : int, optional
[backend='matplotlib'] Radius of the circles, 6 px by default.
circle_label : bool or string, optional
[backend='matplotlib'] Whether to show the coordinates next to each
circle. If a string: the string to be printed. If a tuple, should be
a tuple of strings with same length as 'circle'.
circle_label_color : str, optional
[backend='matplotlib'] Default 'white'. Sets the color of the circle
label
arrow : None or tuple of floats, optional
[backend='matplotlib'] To show an arrow pointing to the given pixel
coordinates.
arrow_alpha : float, optional
[backend='matplotlib'] Alpha transparency for the arrow.
arrow_length : int, optional
[backend='matplotlib'] Length of the arrow, 10 px by default.
arrow_shiftx : int, optional
[backend='matplotlib'] Shift in x of the arrow pointing position, 5 px
by default.
arrow_label : bool or string, optional
[backend='matplotlib'] Label to be printed next to the arrow.
label : None, str or tuple of str/None, optional
[backend='matplotlib'] Text for labeling each subplot. The label is
shown at the bottom-left corner if each subplot.
label_pad : int or tuple of int, optional
[backend='matplotlib'] Padding of the label from the left bottom corner.
5 by default. If a tuple, sets the padding in x and y.
label_size : int, optional
[backend='matplotlib'] Size of the labels font.
grid : bool or tuple of bools, optional
[backend='matplotlib'] If True, a grid is displayed over the image, off
by default.
grid_alpha : None, float/int or tuple of None/float/int, optional
[backend='matplotlib'] Alpha transparency of the grid.
grid_color : str, optional
[backend='matplotlib'] Color of the grid lines.
grid_spacing : None, float/int or tuple of None/float/int, optional
[backend='matplotlib'] Separation of the grid lines in pixels.
cross : None or tuple of floats, optional
[backend='matplotlib'] If provided, a crosshair is displayed at given
pixel coordinates.
cross_alpha : float, optional
[backend='matplotlib'] Alpha transparency of the crosshair.
cross_color : string, optional
[backend='matplotlib'] Color of the crosshair.
ang_scale : bool or tuple of bools, optional
[backend='matplotlib'] If True, the axes are displayed in angular scale
(arcsecs).
ang_ticksep : int, optional
[backend='matplotlib'] Separation for the ticks when using axis in
angular scale.
ndec : int, optional
[backend='matplotlib'] Number of decimals for axes labels.
pxscale : float, optional
[backend='matplotlib'] Pixel scale in arcseconds/px. Default 0.01
(Keck/NIRC2, SPHERE-IRDIS).
auscale : float, optional
[backend='matplotlib'] Pixel scale in au/px. Default 1.
ang_legend : bool or tuple of bools, optional
[backend='matplotlib'] If True a scaling bar (1 arcsec or 500 mas) will
be added on the bottom-right corner of the subplots.
au_legend : bool or tuple of bools, optional
[backend='matplotlib'] If True (and ang_legend is False) a scaling bar
(10 au, 20 au or 50 au) will be added on the top-right corner of the
subplots.
axis : bool, optional
[backend='matplotlib'] Show the axis, on by default.
show_center : bool or tuple of bools, optional
[backend='matplotlib'] To show a cross at the center of the frame.
cmap : None, str or tuple of str, optional
Colormap to be used. When None, the value of the global variable
``default_cmap`` will be used. Any string corresponding to a valid
``matplotlib`` colormap can be used. Additionally, 'ds9cool', 'ds9heat'
and 'binary' (for binary maps) are valid colormaps for this function.
log : bool or tuple of bool, optional
[backend='matplotlib'] Log color scale.
colorbar : bool or tuple of bool, optional
To attach a colorbar, on by default.
colorbar_ticks : None, tuple or tuple of tuples, optional
[backend='matplotlib'] Custom ticks for the colorbar of each plot.
dpi : int, optional
[backend='matplotlib'] Dots per inch, determines how many pixels the
figure comprises (which affects the plot quality).
size_factor : int, optional
[backend='matplotlib'] Determines the size of the plot by setting the
figsize parameter (width x height [inches]) as size_factor * ncols,
size_factor * nrows.
horsp : float, optional
[backend='matplotlib'] Horizontal gap between subplots.
versp : float, optional
[backend='matplotlib'] Vertical gap between subplots.
width : int, optional
[backend='bokeh'] Controls the width of each subplot.
height : int, optional
[backend='bokeh'] Controls the height of each subplot.
title : None or str, optional
[backend='matplotlib'] Title of the whole figure, None by default.
tit_size: int, optional
Size of the title font.
sampling : int, optional
[mode='surface'] Sets the stride used to sample the input data to
generate the surface graph.
save : None or str, optional
If a string is provided the plot is saved using ``save`` as the
path/filename.
transparent : bool, optional
[save=True] Whether to have a transparent background between subplots.
If False, then a white background is shown.
"""
def check_bool_param(param, name):
msg_type = '`' + name + '` must be a bool or tuple of bools'
if isinstance(param, bool):
param = [param] * num_plots
elif isinstance(param, tuple):
if not num_plots == len(param):
msg = 'The len of `' + name + '` ({}) does not match the ' + \
'number of plots ({})'
raise ValueError(msg.format(len(param), num_plots))
else:
for elem in param:
if not isinstance(elem, bool):
raise TypeError(msg_type)
else:
raise TypeError(msg_type)
return param
def check_numeric_param(param, name):
msg_type = '`' + name + '` must be a None, float/int or tuple of ' + \
'None/float/ints'
if param is None:
param = [None] * num_plots
elif isinstance(param, (int, float)):
param = [param] * num_plots
elif isinstance(param, tuple):
if not num_plots == len(param):
msg = 'The len of `' + name + '` ({}) does not match the ' + \
'number of plots ({})'
raise ValueError(msg.format(len(param), num_plots))
else:
for elem in param:
if elem and not isinstance(elem, (float, int)):
raise TypeError(msg_type)
else:
raise TypeError(msg_type)
return param
def check_str_param(param, name, default_value=None):
msg_type = '`' + name + '` must be a None, str or tuple of ' + \
'None/str'
if param is None:
param = [default_value] * num_plots
elif isinstance(param, str):
param = [param] * num_plots
elif isinstance(param, tuple):
if not num_plots == len(param):
msg = 'The len of `' + name + '` ({}) does not match the ' + \
'number of plots ({})'
raise ValueError(msg.format(len(param), num_plots))
else:
for elem in param:
if elem and not isinstance(elem, str):
raise TypeError(msg_type)
else:
raise TypeError(msg_type)
return param
# --------------------------------------------------------------------------
# Checking inputs: a frame (1 or 3 channels) or tuple of them
msg_data_type = "`data` must be a frame (2d array) or tuple of frames"
if isinstance(data, np.ndarray):
if data.ndim == 2:
data = [data]
elif data.ndim == 3:
raise TypeError(msg_data_type)
elif isinstance(data, tuple):
for i in range(len(data)):
# checking the elements are 2d (excepting the case of 3 channels)
if not data[i].ndim == 2:# and data[i].shape[2] != 3:
raise ValueError(msg_data_type)
else:
raise ValueError(msg_data_type)
if not isinstance(backend, str):
raise TypeError('`backend` must be a string. ' + msg_data_type)
if backend == 'bokeh':
if mode == 'surface':
raise ValueError('Surface plotting only supported with matplotlib '
'backend')
if save is not None:
raise ValueError('Saving is only supported with matplotlib backend')
if isinstance(label_pad, tuple):
label_pad_x, label_pad_y = label_pad
else:
label_pad_x = label_pad
label_pad_y = label_pad
num_plots = len(data)
if rows == 0:
raise ValueError('Rows must be a positive integer')
if num_plots % rows == 0:
cols = int(num_plots / rows)
else:
cols = int((num_plots / rows) + 1)
# CIRCLE -------------------------------------------------------------------
if circle is not None:
if isinstance(circle, tuple):
show_circle = True
if isinstance(circle[0], tuple):
n_circ = len(circle)
coor_circle = circle
elif isinstance(circle[0], (float, int)):
n_circ = 1
coor_circle = [circle] * n_circ
else:
print("`circle` must be a tuple (X,Y) or tuple of tuples (X,Y)")
show_circle = False
else:
show_circle = False
if show_circle:
if isinstance(circle_radius, (float, int)):
# single value is provided, used for all circles
circle_radius = [circle_radius] * n_circ
elif isinstance(circle_radius, tuple):
# a different value for each circle
if not n_circ == len(circle_radius):
msg = '`circle_radius` must have the same len as `circle`'
raise ValueError(msg)
else:
raise TypeError("`circle_rad` must be a float or tuple of floats")
if show_circle:
if isinstance(circle_alpha, (float, int)):
circle_alpha = [circle_alpha] * n_circ
elif isinstance(circle_alpha, tuple):
# a different value for each circle
if not n_circ == len(circle_alpha):
msg = '`circle_alpha` must have the same len as `circle`'
raise ValueError(msg)
# ARROW --------------------------------------------------------------------
if arrow is not None:
if isinstance(arrow, tuple):
show_arrow = True
else:
raise ValueError("`arrow` must be a tuple (X,Y)")
else:
show_arrow = False
# VMAX-VMIN ----------------------------------------------------------------
vmin = check_numeric_param(vmin, 'vmin')
vmax = check_numeric_param(vmax, 'vmax')
# CROSS --------------------------------------------------------------------
if cross is not None:
if not isinstance(cross, tuple):
raise ValueError("`crosshair` must be a tuple (X,Y)")
else:
coor_cross = cross
show_cross = True
else:
show_cross = False
# AXIS, GRID, ANG_SCALE ----------------------------------------------------
axis = check_bool_param(axis, 'axis')
grid = check_bool_param(grid, 'grid')
grid_alpha = check_numeric_param(grid_alpha, 'grid_alpha')
grid_spacing = check_numeric_param(grid_spacing, 'grid_spacing')
show_center = check_bool_param(show_center, 'show_center')
ang_scale = check_bool_param(ang_scale, 'ang_scale')
ang_legend = check_bool_param(ang_legend, 'ang_legend')
au_legend = check_bool_param(au_legend, 'au_legend')
if isinstance(grid_color, str):
grid_color = [grid_color] * num_plots
if any(ang_scale) and save is not None:
print("`Pixel scale set to {}`".format(pxscale))
# LABEL --------------------------------------------------------------------
label = check_str_param(label, 'label')
# CMAP ---------------------------------------------------------------------
custom_cmap = check_str_param(cmap, 'cmap', default_cmap)
# COLORBAR -----------------------------------------------------------------
colorbar = check_bool_param(colorbar, 'colorbar')
if colorbar_ticks is not None:
cbar_ticks = colorbar_ticks
# must be a tuple
if isinstance(cbar_ticks, tuple):
# tuple of tuples
if isinstance(cbar_ticks[0], tuple):
if not num_plots == len(cbar_ticks):
raise ValueError('`colorbar_ticks` does not contain enough '
'items')
# single tuple
elif isinstance(cbar_ticks[0], (float, int)):
cbar_ticks = [colorbar_ticks] * num_plots
else:
raise TypeError('`colorbar_ticks` must be a tuple or tuple of '
'tuples')
else:
cbar_ticks = [None] * num_plots
# LOG ----------------------------------------------------------------------
logscale = check_bool_param(log, 'log')
# if any(logscale):
# # Showing bad/nan pixels with the darkest color in current colormap
# current_cmap = mplcm.get_cmap()
# current_cmap.set_bad(current_cmap.colors[0])
# --------------------------------------------------------------------------
if backend == 'matplotlib':
# Creating the figure --------------------------------------------------
fig = figure(figsize=(cols * size_factor, rows * size_factor), dpi=dpi)
if title is not None:
fig.suptitle(title, fontsize=tit_size, va='center', x=0.51,
#y=1-0.08*(28/tit_size)**(0.5))
y=1-0.1*(16/tit_size))
if mode == 'surface':
plot_mosaic = False
elif mode == 'mosaic':
plot_mosaic = True
else:
raise ValueError("`mode` value was not recognized")
for i, v in enumerate(range(num_plots)):
image = data[i].copy()
frame_size = image.shape[0] # assuming square frames
cy = image.shape[0] / 2 - 0.5
cx = image.shape[1] / 2 - 0.5
v += 1
if plot_mosaic:
ax = subplot(rows, cols, v)
ax.set_aspect('auto')
if logscale[i]:
image += np.abs(np.nanmin(image))
if vmin[i] is None:
linthresh = 1e-2
else:
linthresh = vmin[i]
norm = colors.SymLogNorm(linthresh, base=10)
else:
norm = None
if image.dtype == bool:
image = image.astype(int)
if custom_cmap[i] == 'binary' and image.max() == 1 and \
image.min() == 0:
cucmap = cmap_binary
cbticks = (0, 0.5, 1)
else:
cucmap = custom_cmap[i]
cbticks = cbar_ticks[i]
im = ax.imshow(image, cmap=cucmap, origin='lower', norm=norm,
interpolation='nearest', vmin=vmin[i],
vmax=vmax[i])
if colorbar[i]:
divider = make_axes_locatable(ax)
# the width of cax is 5% of ax and the padding between cax
# and ax wis fixed at 0.05 inch
cax = divider.append_axes("right", size="5%", pad=0.05)
cb = plt_colorbar(im, ax=ax, cax=cax, drawedges=False,
ticks=cbticks)
cb.outline.set_linewidth(0.1)
cb.ax.tick_params(labelsize=lab_fontsize)
else:
# Leave the import to make porjection='3d' work
#from mpl_toolkits.mplot3d import Axes3D
x = np.outer(np.arange(0, frame_size, 1), np.ones(frame_size))
y = x.copy().T
ax = subplot(rows, cols, v, projection='3d')
ax.set_aspect('auto')
surf = ax.plot_surface(x, y, image, rstride=sampling,
cstride=sampling, linewidth=2,
cmap=custom_cmap[i], antialiased=True,
vmin=vmin[i], vmax=vmax[i])
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.dist = 10
if title is not None:
ax.set_title(title)
if colorbar[i]:
fig.colorbar(surf, aspect=10, pad=0.05, fraction=0.04)
if ang_legend[i] and plot_mosaic:
scaleng = 1. / pxscale
scalab = '1 arcsec'
scalabloc = scaleng / 2. - 8
if scaleng > frame_size / 2.:
scaleng /= 2.
scalab = '500 mas'
scalabloc = scaleng / 2. - 8
scapad = 4
xma = frame_size - scapad
xmi = xma - scaleng
hlines(y=scapad, xmin=xmi, xmax=xma, colors='white', lw=1.,
linestyles='solid')
annotate(scalab, (xmi + scalabloc, scapad + 2), color='white',
size=label_size)
elif au_legend[i] and plot_mosaic:
pxsc_fac = (0.012265/pxscale)
labsz_fac = (label_size/12)
scaleng = 50. / auscale
scalab = '50 au'
scalabloc = scaleng / 2. - 6.4*pxsc_fac*labsz_fac
if scaleng > frame_size / 3.:
scaleng = 20. / auscale
scalab = '20 au'
scalabloc = scaleng / 2. - 6.4*pxsc_fac*labsz_fac
if scaleng > frame_size / 3.:
scaleng = 10. / auscale
scalab = '10 au'
scalabloc = scaleng / 2. - 6.4*pxsc_fac*labsz_fac
scapad = 5*pxsc_fac*labsz_fac
xma = frame_size - scapad
xmi = xma - scaleng
hlines(y=xma-scapad, xmin=xmi, xmax=xma, colors='white', lw=1.,
linestyles='solid')
annotate(scalab, (xmi + scalabloc, xma-0.5*scapad),
color='white', size=label_size)
if show_circle and plot_mosaic:
if isinstance(circle_linestyle,tuple):
c_offset = circle_linestyle[0]
circle_linestyle = circle_linestyle[1]
else:
c_offset = lab_fontsize+1 # vertical offset is equal to the font size + 1, was 2
for j in range(n_circ):
if isinstance(circle_color, (list, tuple)):
circle_color_tmp = circle_color[j]
else:
circle_color_tmp = circle_color
if isinstance(circle_linestyle, (list, tuple)):
circle_linestyle_tmp = circle_linestyle[j]
else:
circle_linestyle_tmp = circle_linestyle
circ = Circle(coor_circle[j], radius=circle_radius[j],
fill=False, color=circle_color_tmp,
alpha=circle_alpha[j], ls=circle_linestyle_tmp)
ax.add_artist(circ)
if circle_label:
x = coor_circle[j][0]
y = coor_circle[j][1]
if isinstance(circle_label,str):
cirlabel = circle_label
elif isinstance(circle_label,tuple):
cirlabel = circle_label[j]
else:
cirlabel = str(int(x))+','+str(int(y))
ax.text(x, y + circle_radius[j] + c_offset, cirlabel,
fontsize=lab_fontsize, color=circle_label_color, family='monospace',
ha='center', va='center', weight='bold',
alpha=circle_alpha[j])
if show_cross and plot_mosaic:
ax.axhline(coor_cross[0], xmin=0, xmax=frame_size, alpha=cross_alpha, lw=0.6,
linestyle='dashed', color='white')
ax.axvline(coor_cross[1], ymin=0, ymax=frame_size, alpha=cross_alpha, lw=0.6,
linestyle='dashed', color='white')
if show_center[i] and plot_mosaic:
ax.scatter([cy], [cx], marker='+',
color=cross_color, alpha=cross_alpha)
if show_arrow and plot_mosaic:
ax.arrow(arrow[0] + arrow_length + arrow_shiftx, arrow[1],
-arrow_length, 0, color='white', head_width=6,
head_length=4, width=2, length_includes_head=True,
alpha=arrow_alpha)
if arrow_label:
x = arrow[0]
y = arrow[1]
if isinstance(arrow_label,str):
arrlabel = arrow_label
else:
arrlabel = str(int(x))+','+str(int(y))
if len(arrlabel) < 5:
arr_fontsize=14
else:
arr_fontsize=lab_fontsize
ax.text(x + arrow_length + 1.3*arrow_shiftx, y, arrlabel,
fontsize=arr_fontsize, color='white', family='monospace',
ha='left', va='center', weight='bold',
alpha=arrow_alpha)
if label[i] is not None and plot_mosaic:
ax.annotate(label[i], xy=(label_pad_x, label_pad_y), color=label_color,
xycoords='axes pixels', weight='bold',
size=label_size)
if grid[i] and plot_mosaic:
if grid_spacing[i] is None:
if cy < 10:
gridspa = 1
elif cy >= 10:
if cy % 2 == 0:
gridspa = 4
else:
gridspa = 5
else:
gridspa = grid_spacing[i]
ax.tick_params(axis='both', which='minor')
minor_ticks = np.arange(0, data[i].shape[0], gridspa)
ax.set_xticks(minor_ticks, minor=True)
ax.set_yticks(minor_ticks, minor=True)
ax.grid(True, which='minor', color=grid_color[i], linewidth=0.5,
alpha=grid_alpha[i], linestyle='dashed')
else:
ax.grid(False)
if ang_scale[i] and plot_mosaic:
# Converting axes from pixels to arcseconds
half_num_ticks = int(np.round(cy // ang_ticksep))
# Calculate the pixel locations at which to put ticks
ticks = []
for t in range(half_num_ticks, -half_num_ticks-1, -1):
# Avoid ticks not showing on the last pixel
if not cy - t * ang_ticksep == frame_size:
ticks.append(cy - t * ang_ticksep)
else:
ticks.append((cy - t * ang_ticksep)-1)
ax.set_xticks(ticks)
ax.set_yticks(ticks)
# Corresponding distance in arcseconds, measured from the center
labels_y = []
labels_x = []
for t in range(half_num_ticks, -half_num_ticks-1, -1):
labels_y.append(round(Decimal(-t * (ang_ticksep * pxscale)),ndec))
labels_x.append(round(Decimal(t * (ang_ticksep * pxscale)),ndec))
ax.set_xticklabels(labels_x)
ax.set_yticklabels(labels_y)
ax.set_xlabel('\u0394RA["]', fontsize=label_size)
ax.set_ylabel('\u0394Dec["]', fontsize=label_size)
ax.tick_params(axis='both', which='major', labelsize=label_size)
else:
ax.set_xlabel("x", fontsize=label_size)
ax.set_ylabel("y", fontsize=label_size)
if not axis[i]:
ax.set_axis_off()
fig.subplots_adjust(wspace=horsp, hspace=versp)
if save is not None and isinstance(save, str):
savefig(save, dpi=dpi, bbox_inches='tight', pad_inches=0,
transparent=transparent)
close()
else:
show()
elif backend == 'bokeh':
hv.extension(backend)
subplots = []
# options = "Image (cmap='" + custom_cmap[0] + "')" # taking first item
# hv.opts(options)
for i, v in enumerate(range(num_plots)):
image = data[i].copy()
if vmin[i] is None:
vmin[i] = image.min()
if vmax[i] is None:
vmax[i] = image.max()
im = hv.Image((range(image.shape[1]), range(image.shape[0]), image))
subplots.append(im.opts(tools=['hover'], colorbar=colorbar[i],
colorbar_opts={'width': 15},
width=width, height=height,
clim=(vmin[i], vmax[i]),
cmap=custom_cmap[0]))
return hv.Layout(subplots).cols(cols)
else:
raise ValueError('`backend` not supported')
def plot():
#################################################################333333
# Final plot.
# High Significant
from shapely.geometry import Point, Polygon
import pandas as pd
import numpy as np
import geoviews as gv
import bokeh
import panel as pn
import holoviews as hv
from holoviews import opts
from holoviews.operation.datashader import datashade, rasterize
hv.extension("bokeh")
import math
from bokeh.models import HoverTool
from scipy.interpolate import griddata
from scipy.io import loadmat
import datetime
from dateutil.parser import parse
from datetime import timedelta
import time
strtt = time.time()
datamat = loadmat('IOEC_ECM_noDA_20190703_masked.mat')
# datamat = loadmat('IOEC_ECM_DA_20191121_masked.mat')
Xp = datamat['Xp']
Yp = datamat['Yp']
# Xp=np.where(((Xp>= 85) & (Xp<=88) & (Yp>=19) & (Yp<=22)),Xp,88)
# Yp=np.where(((Xp>= 85) & (Xp<=88) & (Yp>=19) & (Yp<=22)),Yp,22)
strt = datetime.datetime(2019, 7, 4, 0, 0)
end = datetime.datetime(2019, 1, 13, 0, 0)
from bokeh.models.callbacks import CustomJS
def perdelta(strt, end, delta):
curr = strt
while curr < end:
yield curr
curr += delta
# Read element file
tri_new = pd.read_csv('fort.ele',
delim_whitespace=True,
names=('A', 'B', 'C', 'D'),
usecols=[1, 2, 3],
skiprows=1,
dtype={'D': np.int})
dateList = []
def plotsecond(datetime, regions='Whole_East_Coast'):
dat = datetime
# datetostr=result.strftime("%Y%b%d%H")
dt = parse(str(dat))
yr = dt.year
mn = dt.month
d = dt.day
hr = dt.hour
mi = dt.minute
if hr < 10:
hr = '0' + str(hr)
else:
d = str(d)
hr = str(hr)
if int(d) < 10:
d = '0' + str(d)
else:
d = str(d)
# varname = 'Hsig_' + str(yr) + '0' + str(mn) + str(d) + '_' + hr + '0000'
Xp = datamat['Xp']
Yp = datamat['Yp']
x = Xp.flatten()
y = Yp.flatten()
Longitude = x
Latitude = y
pkname = 'PkDir_' + str(yr) + '0' + str(mn) + str(
d) + '_' + hr + '0000'
pkvalue = datamat[pkname]
if regions is 'Odisha':
pkvalue = np.where(
((Xp >= 85) & (Xp <= 88) & (Yp >= 19) & (Yp <= 22)), pkvalue,
np.nan).flatten()
elif regions is 'Andra_Pradesh':
pkvalue = np.where(
((Xp >= 79) & (Xp <= 85) & (Yp >= 13) & (Yp <= 19)), pkvalue,
np.nan).flatten()
elif regions is 'Tamil_Nadu':
pkvalue = np.where(
((Xp >= 77) & (Xp <= 83) & (Yp >= 7) & (Yp <= 14)), pkvalue,
np.nan).flatten()
elif regions is 'Whole_East_Coast':
pkvalue = pkvalue.flatten()
else:
# data = get_data4region(data,**odisha)
pkvalue = pkvalue.flatten()
pkvalue = pkvalue.flatten()
d = pkvalue * (math.pi / 180)
# target grid to interpolate to
xt = np.arange(76.937, 92.008, 0.1)
yt = np.arange(1.482, 22.461, 0.1)
xi, yi = np.meshgrid(xt, yt)
di = griddata((Longitude, Latitude), d, (xi, yi))
dfcoast = pd.read_csv('ECpolygonTwoDegreeOffsetBorder.txt',
delim_whitespace=True,
names=('X', 'Y'))
dfcoast['geometry'] = dfcoast.apply(lambda row: Point(row.X, row.Y),
axis=1)
poly = Polygon([(p.x, p.y) for p in dfcoast.geometry])
arr = np.zeros((len(yt), len(xt)))
for i in range(len(xt)):
for j in range(len(yt)):
point = Point(xt[i], yt[j])
arr[j, i] = poly.contains(point)
mask = (xi > 79.7817) & (xi < 81.2718) & (yi > 7.6951) & (yi < 9.7406)
di[mask] = np.nan
di[arr == False] = np.nan
U = np.cos(di)
V = np.sin(di)
mag = np.sqrt(U**2 + V**2)
angle = (np.pi / 2.) - np.arctan2(U / mag, V / mag)
vec = gv.VectorField(
(xi[::5, ::5], yi[::5, ::5], angle[::5, ::5], mag[::5, ::5]))
return vec
def plotthis(datetime, regions='Whole_East_Coast'):
dat = datetime
# datetostr=result.strftime("%Y%b%d%H")
dt = parse(str(dat))
yr = dt.year
mn = dt.month
d = dt.day
hr = dt.hour
mi = dt.minute
if hr < 10:
hr = '0' + str(hr)
else:
d = str(d)
hr = str(hr)
if int(d) < 10:
d = '0' + str(d)
else:
d = str(d)
varname = 'Hsig_' + str(yr) + '0' + str(mn) + str(
d) + '_' + hr + '0000'
x = Xp.flatten()
y = Yp.flatten()
z = datamat[varname]
if regions is 'Odisha':
z = np.where(((Xp >= 85) & (Xp <= 88) & (Yp >= 19) & (Yp <= 22)),
z, np.nan).flatten()
elif regions is 'Andra_Pradesh':
z = np.where(((Xp >= 79) & (Xp <= 85) & (Yp >= 13) & (Yp <= 19)),
z, np.nan).flatten()
elif regions is 'Tamil_Nadu':
z = np.where(((Xp >= 77) & (Xp <= 83) & (Yp >= 7) & (Yp <= 14)), z,
np.nan).flatten()
elif regions is 'Whole_East_Coast':
z = z.flatten()
else:
# data = get_data4region(data,**odisha)
z = z.flatten()
# z = z.flatten()
Longitude = x
Latitude = y
High_Significant = z
pts = np.stack((Longitude, Latitude, High_Significant)).T
verts = pd.DataFrame(
np.stack((Longitude, Latitude, High_Significant)).T,
columns=['Longitude', 'Latitude', ' High_Significant'])
# openStreet Background.
tri_sub = tri_new.apply(lambda x: x - 1)
ggpoints = gv.Points(verts, vdims=[' High_Significant'])
ggsubraster = rasterize(gv.TriMesh((tri_sub, gv.Points(verts))))
tri = gv.TriMesh((tri_sub, gv.Points(verts)))
return tri
allplot = {
(k.strftime("%Y-%m-%d %H:%M:%S"), r): plotthis(k, r)
for k in perdelta(strt, strt + timedelta(days=2), timedelta(hours=18))
for r in ['Odisha', 'Andra_Pradesh', 'Whole_East_Coast', 'Tamil_Nadu']
}
allplot2 = {
(k.strftime("%Y-%m-%d %H:%M:%S"), r): plotsecond(k, r)
for k in perdelta(strt, strt + timedelta(days=2), timedelta(hours=18))
for r in ['Odisha', 'Andra_Pradesh', 'Whole_East_Coast', 'Tamil_Nadu']
}
df_div = hv.Div("""
<figure>
<img src="https://i.ibb.co/S0t5GWb/imglogo.png" height='80' width='90' vspace='-10'>
""")
df_div1 = hv.Div("""
 <center><b><p style="color:#B22222";font-size:80px;font-family:Times new roman><h1 style=font-size:20px;margin-left:2.5em;margin-top:-1em;color:#B22222>Indian National Center for Ocean Information Services<br />
(INCOIS)</h1></p></b></center>
""")
colorbar_opts = {
'major_label_overrides': {
0: '0',
0.5: '0.5',
1: '1',
1.5: '1.5',
2: '2',
2.5: '2.5',
3: '3',
3.5: '>3.5',
3.8: '>4 ',
3.9: '>3.9',
},
'major_label_text_align': 'left',
'major_label_text_font_style': 'bold',
}
levels = [
0,
0.2,
0.4,
0.6,
0.8,
1,
1.2,
1.4,
1.6,
1.8,
2,
2.2,
2.5,
3,
]
def disable_logo(plot, element):
plot.state.toolbar.logo = None
hv.plotting.bokeh.ElementPlot.finalize_hooks.append(disable_logo)
# logo1 = hv.RGB.load_image("imglogo.png")
logo1 = hv.RGB.load_image("https://i.ibb.co/7VXRPCS/logo1.png")
def absolute_position(plot, element):
glyph = plot.handles['glyph']
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
glyph.dh_units = 'screen'
glyph.dw_units = 'screen'
glyph.dh = 60
glyph.dw = 90
glyph.x = x_range.start
glyph.y = y_range.start
xcode = CustomJS(code="glyph.x = cb_obj.start", args={'glyph': glyph})
plot.handles['x_range'].js_on_change('start', xcode)
ycode = CustomJS(code="glyph.y = cb_obj.start", args={'glyph': glyph})
plot.handles['y_range'].js_on_change('start', ycode)
def plot_limits(plot, element):
plot.handles['x_range'].min_interval = 100
plot.handles['x_range'].max_interval = 55000000
# 3000000
plot.handles['y_range'].min_interval = 500
plot.handles['y_range'].max_interval = 900000
opts = dict(
width=700,
height=700,
tools=['hover', 'save', 'wheel_zoom'],
active_tools=['wheel_zoom'],
hooks=[plot_limits, disable_logo],
colorbar=True,
color_levels=15,
colorbar_opts=colorbar_opts,
cmap=[
'#000080',
'#0000cd',
'#0008ff',
'#004cff',
'#0090ff',
'#00d4ff',
'#29ffce',
'#60ff97',
'#97ff60',
'#ceff29',
'#ffe600',
'#ffa700',
# '#ff6800',
'#ff2900',
'#cd0000',
'#800000',
],
clim=(0, 3.76),
title="\tSignificant Wave Height (m) and Direction (°) ",
fontsize={
'title': 18,
'xlabel': 15,
'ylabel': 15,
'ticks': 12
})
tiles = gv.tile_sources.Wikipedia
hmap1 = hv.HoloMap(allplot,
kdims=['Select Date and Time :', 'Select Indian State'])
hmap2 = hv.HoloMap(allplot2,
kdims=['Select Date and Time :', 'Select Indian State'])
dd = df_div.opts(width=70, height=70)
dd1 = df_div1.opts(width=600, height=90)
finalplot = pn.Column(
pn.Row(dd, dd1),
tiles * rasterize(hmap1).options(**opts) * hmap2 *
logo1.opts(hooks=[absolute_position], apply_ranges=False)).servable()
# print("--- %s seconds ---" % (time.time() - strtt))
from bokeh.embed import components
from bokeh.resources import CDN
from bokeh.io import curdoc
doc = curdoc()
script, div = components(finalplot.get_root(doc))
cdn_js0 = CDN.js_files[0]
cdn_js = CDN.js_files[1]
cdn_css = CDN.css_files
print("cdn_js:", cdn_js)
print("cdn_css", cdn_css)
return render_template("plot.html",
script=script,
div=div,
cdn_css=cdn_css,
cdn_js=cdn_js,
cdn_js0=cdn_js0)
def plot_cubes(cube, mode='slider', backend='matplotlib', dpi=100,
figtype='png', vmin=None, vmax=None, size=100, width=360,
height=360, cmap=None, colorbar=True, dynamic=True,
anim_path=None, data_step_range=None, label=None,
label_step_range=None, delay=50, anim_format='gif',
delete_anim_cache=True, **kwargs):
""" Plot multi-dimensional high-contrast imaging datacubes (3d and 4d
``numpy`` arrays). It allows to visualize in-memory ``numpy`` arrays on
``Jupyterlab`` by leveraging the ``HoloViews`` library. It can also generate
and save animations from a 3d ``numpy`` array with ``matplotlib``.
Parameters
----------
cube : np.ndarray
Input 3d or 4d cube.
mode : {'slider', 'animation'}, str optional
Whether to plot the 3d array as a widget with a slider or to save an
animation of the 3d array. The animation is saved to disk using
ImageMagick's convert command (it must be installed otherwise a
``FileNotFoundError`` will be raised).
backend : {'matplotlib', 'bokeh'}, str optional
Selects the backend used to display the plots. ``Bokeh`` plots are
interactive, allowing the used to zoom, pan, inspect pixel values, etc.
``Matplotlib`` can lead to some flickering when using the slider and
``dynamic`` is True.
dpi : int, optional
[backend='matplotlib'] The rendered dpi of the figure.
figtype : {'png', 'svg'}, str optional
[backend='matplotlib'] Type of output.
vmin : None, float or int, optional
For defining the data range that the colormap covers. When set to None,
the colormap covers the complete value range of the supplied data.
vmax : None, float or int, optional
For defining the data range that the colormap covers. When set to None,
the colormap covers the complete value range of the supplied data.
size : int, optional
[backend='matplotlib'] Sets the size of the plot.
width : int, optional
[backend='bokeh'] Sets the width of the plot.
height : int, optional
[backend='bokeh'] Sets the height of the plot.
cmap : None or str, optional
Colormap. When None, the value of the global variable ``default_cmap``
will be used.
colorbar : bool, optional
If True, a colorbar is shown.
dynamic : bool, optional
[mode='slider'] When False, a ``HoloViews.HoloMap`` is created (slower
and will take up a lot of RAM for large datasets). If True, a
``HoloViews.DynamicMap`` is created instead.
anim_path : str, optional
[mode='animation'] The animation path/filename. If None then the
animation will be called ``animation``.``anim_format`` and will be saved
in the current directory.
data_step_range : tuple, optional
[mode='animation'] Tuple of 1, 2 or 3 values that creates a range for
slicing the ``data`` cube.
label : str, optional
[mode='animation'] Label to be overlaid on top of each frame of the
animation. If None, then ``frame <#>`` will be used.
label_step_range : tuple, optional
[mode='animation'] Tuple of 1, 2 or 3 values that creates a range for
customizing the label overlaid on top of each frame of the animation.
delay : int, optional
[mode='animation'] Delay for displaying the frames in the animation
sequence.
anim_format : str, optional
[mode='animation'] Format of the saved animation. By default 'gif' is
used. Other formats supported by ImageMagick are valid, such as 'mp4'.
delete_anim_cache : str, optional
[mode='animation'] If True, the cache folder is deleted once the
animation file is saved to disk.
**kwargs : dictionary, optional
[mode='animation'] Arguments to be passed to ``plot_frames`` to
customize each frame of the animation (adding markers, using a log
scale, etc).
Notes
-----
http://holoviews.org/getting_started/Gridded_Datasets.html
http://holoviews.org/user_guide/Gridded_Datasets.html
http://holoviews.org/user_guide/Applying_Customizations.html
"""
hv.extension(backend)
if not isinstance(cube, np.ndarray):
raise TypeError('`cube` must be a numpy.ndarray')
if cmap is None:
cmap = default_cmap
if mode == 'slider':
if cube.ndim not in (3, 4):
raise ValueError('`cube` must be a 3 or 4 array when `mode` set to '
'slider')
if cube.ndim == 3:
# Dataset((X, Y, Z), Data), where
# X is a 1D array of shape M ,
# Y is a 1D array of shape N and
# Z is a 1D array of shape O
# Data is a ND array of shape NxMxO
ds = hv.Dataset((range(cube.shape[2]), range(cube.shape[1]),
range(cube.shape[0]), cube), ['x', 'y', 'time'],
'flux')
max_frames = cube.shape[0]
elif cube.ndim == 4:
# adding a lambda dimension
ds = hv.Dataset((range(cube.shape[3]), range(cube.shape[2]),
range(cube.shape[1]), range(cube.shape[0]), cube),
['x', 'y', 'time', 'lambda'], 'flux')
max_frames = cube.shape[0] * cube.shape[1]
# Matplotlib takes None but not Bokeh. We take global min & max instead
if vmin is None:
vmin = cube.min()
if vmax is None:
vmax = cube.max()
print(ds)
print(":Cube_shape\t{}".format(list(cube.shape[::-1])))
# not working for bokeh: dpi
image_stack = ds.to(hv.Image, kdims=['x', 'y'], dynamic=dynamic)
hv.output(backend=backend, size=size, dpi=dpi, fig=figtype,
max_frames=max_frames)
if backend == 'matplotlib':
# keywords in the currently active 'matplotlib' renderer are:
# 'alpha', 'clims', 'cmap', 'filterrad', 'interpolation', 'norm',
# 'visible'
#options = "Image (cmap='" + cmap + "', interpolation='nearest',"
#options += " clims=("+str(vmin)+','+str(vmax)+")"+")"
#opts(options, image_stack)
return image_stack.opts(opts.Image(colorbar=colorbar,
cmap=cmap,
clim=(vmin, vmax)))
# hv.save(image_stack, 'holomap.gif', fps=5)
elif backend == 'bokeh':
#options = "Image (cmap='" + cmap + "')"
#opts(options, image_stack)
# Compensating the width to accommodate the colorbar
if colorbar:
cb_wid = 15
cb_pad = 3
tick_len = len(str(int(cube.max())))
if tick_len < 4:
cb_tick = 25
elif tick_len == 4:
cb_tick = 35
elif tick_len > 4:
cb_tick = 45
width_ = width + cb_pad + cb_wid + cb_tick
else:
width_ = width
return image_stack.opts(opts.Image(colorbar=colorbar,
colorbar_opts={'width': 15,
'padding': 3},
width=width_, height=height,
clim=(vmin, vmax),
cmap=cmap,
tools=['hover']))
elif mode == 'animation':
if cube.ndim != 3:
raise ValueError('`cube` must be a 3 array when `mode` set to '
'animation')
if backend == 'bokeh':
print('Creating animations works with the matplotlib backend')
dir_path = './animation_temp/'
if anim_path is None:
anim_path = './animation'
if data_step_range is None:
data_step_range = range(0, cube.shape[0], 1)
else:
if not isinstance(data_step_range, tuple):
msg = '`data_step_range` must be a tuple with 1, 2 or 3 values'
raise ValueError(msg)
if len(data_step_range) == 1:
data_step_range = range(data_step_range)
elif len(data_step_range) == 2:
data_step_range = range(data_step_range[0], data_step_range[1])
elif len(data_step_range) == 3:
data_step_range = range(data_step_range[0],
data_step_range[1],
data_step_range[2])
if label_step_range is None:
label_step_range = data_step_range
else:
if not isinstance(label_step_range, tuple):
msg = '`label_step_range` must be a tuple with 1, 2 or 3 values'
raise ValueError(msg)
if len(label_step_range) == 1:
label_step_range = range(label_step_range)
elif len(label_step_range) == 2:
label_step_range = range(label_step_range[0],
label_step_range[1])
elif len(label_step_range) == 3:
label_step_range = range(label_step_range[0],
label_step_range[1],
label_step_range[2])
if os.path.exists(dir_path):
shutil.rmtree(dir_path)
print('Replacing ' + dir_path)
os.mkdir(dir_path)
print('Producing each animation frame...')
for i, labstep in zip(data_step_range, list(label_step_range)):
if label is None:
label = 'frame '
savelabel = dir_path + label + str(i + 100)
plot_frames(cube[i], backend='matplotlib', mode='mosaic',
save=savelabel, dpi=dpi, vmin=vmin, vmax=vmax,
colorbar=colorbar, cmap=cmap,
label=[label + str(labstep + 1)], **kwargs)
try:
filename = anim_path + '.' + anim_format
call(['convert', '-delay', str(delay), dir_path + '*.png',
filename])
if os.path.exists(filename):
print('Animation successfully saved to disk as ' + filename)
if delete_anim_cache:
shutil.rmtree(dir_path)
print('Temp directory deleted ' + dir_path)
except FileNotFoundError:
print('ImageMagick `convert` command could not be found')
else:
raise ValueError("`mode` is not recognized")
def wrapper(*args, **kwargs):
if extension and not getattr(hv.extension, '_loaded', False):
hv.extension(extension, logo=logo)
return func(*args, **kwargs)
from bokeh.sampledata import gapminder
from holoviews import dim
from holoviews import opts
from holoviews.plotting.bokeh import BokehRenderer
# In[5]:
l = ["#40fe10", "#fffe10", "#f25000", "#ff0f00"]
# ### Gapminder test
# In[6]:
renderer = hv.renderer('bokeh')
hv.extension('plotly')
hv.extension('bokeh')
# In[7]:
df = pd.read_csv("/home/atez/Scrivania/web valley/milano_cleaned.csv")
# In[24]:
#print(df.columns.values)
# In[9]:
df_medical = df[[
'cod_pz', 'visit:visit', 'ult_tsa:imt_cc_average_right',
'lab:total_cholesterol', 'lab:calculated_ldl', 'ScoreClass'
def plot_policy_gantt_chart(
policies,
effects=False,
colors="categorical",
fig_kwargs=None,
):
"""Plot a Gantt chart of the policies."""
if fig_kwargs is None:
fig_kwargs = {}
fig_kwargs = {**DEFAULT_FIGURE_KWARGS, **fig_kwargs}
if isinstance(policies, dict):
df = (pd.DataFrame(policies).T.reset_index().rename(columns={
"index": "name"
}).astype({
"start": "datetime64",
"end": "datetime64"
}).drop(columns="policy"))
elif isinstance(policies, pd.DataFrame):
df = policies
else:
raise ValueError(
"'policies' should be either a dict or pandas.DataFrame.")
if effects:
effect_kwargs = effects if isinstance(effects, dict) else {}
effects = compute_pseudo_effect_sizes_of_policies(policies=policies,
**effect_kwargs)
effects_s = pd.DataFrame([{
"policy": name,
"effect": effects[name]["mean"]
} for name in effects]).set_index("policy")["effect"]
df = df.merge(effects_s, left_on="name", right_index=True)
df["alpha"] = (1 - df["effect"] + 0.1) / 1.1
else:
df["alpha"] = 1
df = df.reset_index()
df = _complete_dates(df)
df = _add_color_to_gantt_groups(df, colors)
df = _add_positions(df)
hv.extension("bokeh", logo=False)
segments = hv.Segments(
df,
[
hv.Dimension("start", label="Date"),
hv.Dimension("position", label="Affected contact model"),
"end",
"position",
],
)
y_ticks_and_labels = list(zip(*_create_y_ticks_and_labels(df)))
tooltips = [("Name", "@name")]
if effects:
tooltips.append(("Effect", "@effect"))
hover = HoverTool(tooltips=tooltips)
gantt = segments.opts(
color="color",
alpha="alpha",
tools=[hover],
yticks=y_ticks_and_labels,
**fig_kwargs,
)
return gantt
import glob
import argparse
import os.path
import xarray
import sonar.lowrance_log_parser
import sonar.map
import sonar.normalized_depth
import sonar.all
import sonar.merged_position
DEBUG_EXCEPTIONS = False
# Configure the default renderer
holoviews.extension('bokeh')
renderer = holoviews.renderer('bokeh').instance(mode='server')
def GenMapImage(sonar_data):
try:
holoviews_map = sonar.map.GenMap(sonar_data)
# @todo There is a bug somehow where the map tiles dont load in time and renders a white square
time.sleep(10)
map_file_name = sonar_data.attrs['gen_name'] + '.map.png'
logger.info('Saving map image: %s', map_file_name)
holoviews.save(holoviews_map, map_file_name)
except:
logger.exception('Failed to produce map image for: %s',
sonar_data.attrs['file_name'])
def interactive_map(v1, options):
"""
Creates and interactive map of the variable v1 on the cruise track contained in options['gps_file']
:param v1: dataframe / series containing the variable to be visualized
:param options:
- options['plot_size'] : global figure scaling (make all of them larger of smaller by this multiplier), except the interactive plots\n",
- options['figsize'] : width, height for the interactive plot\n",
- options['scatter_markersize'] : size of the markers in the scatterplot\n",
- options['map_scatter_markersize'] : size of the markers in the static geographical map\n",
- options['map_temporal_aggregation'] : Hours to aggregate in the static and interactive geographical map.\n",
- options['resampling_operation'] : resample points on map temporally,
- options['colormap'] : colormap from plt.cm
- options['gps_file'] : file containing the gps coordinates
:returns: interactive figure object
"""
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])
# segmentation Mariangela's data
import os
import time
import pickle
import warnings
import scipy.stats
import numpy as np
import pandas as pd
import caiman as cm
import seaborn as sns
import holoviews as hv
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle
import utils_mari as ut
hv.extension('matplotlib')
# Do the segmentation with agonia
data_path = '/media/pedro/DATAPART1/Mariangela/20200313/area02_0002-1561' #folder where the tif movie and the median projection are
data_name, median_projection, boxes_path = ut.get_files_names(data_path)
ut.agonia_detect(data_path, data_name, median_projection,
multiplier=.7) #boxes are saved as pickle files
# extract and save traces
agonia_th = .2 #choose a threshold of confidence for the detected boxes
traces = ut.traces_extraction_AGONIA(data_path, agonia_th)
#save results
df = pd.DataFrame(traces)
df.to_hdf(os.path.join(data_path,
os.path.splitext(data_name[0])[0] + '_traces.hdf5'),
key='df',
mode='w')
# %%
from fractions import Fraction
from importlib import reload
import holoviews as hv
import numpy as np
from holoviews import opts
import hw2
hv.extension('bokeh', 'matplotlib')
opts.defaults(opts.Curve(width=650))
conf = np.loadtxt('60.txt')
conf100, conf200 = np.loadtxt('100.txt'), np.loadtxt('200.txt')
# %%
deltas = [Fraction(1, 6), Fraction(1, 3), 1, 2, 3]
E, E_corr, err, acc_rate = hw2.point_b(conf, np.array(deltas, np.float))
# yapf: disable
print('delta values (in units of d):', [str(d) for d in deltas],
'means and errors:', E.mean(1), err, 'acceptance ratios:', acc_rate,
sep='\n')
E_plot = hv.NdOverlay({delta: hv.Curve(E[i, ::40])
for i, delta in enumerate(deltas)}).redim(x='t', y='E')
acc_plot = hv.Curve((np.array(deltas, np.float), acc_rate))
E_corr_plot = hv.NdOverlay({delta: hv.Curve(E_corr[i, :300])
for i, delta in enumerate(deltas)})
err_plot = hv.Curve((list(map(float, deltas)), err))
# yapf: enable
def test_holoview():
import holoviews as hv
hv.extension('bokeh')
model = Generate()
alloc = Amounts() + Simulation()
exec = sim.engine.BasicExecution(model, alloc)
tr = model['grow', 'const', 'alt']
ht = tr.take(6).to(sim.trace.Holotrace)
assert 'Holotrace' in str(ht)
assert str(ht.trace) in str(ht)
assert repr(ht.trace) in repr(ht)
assert list(ht.data.columns) == ['grow', 'const', 'alt']
assert list(ht.data.index.names) == ['trace', 'sample']
dm = ht.plot(hv.Curve)
hv.render(dm) # trigger rendering, so dynamic map gets filled
over, = dm
assert len(over) == 6 * 3
crv, *_ = over
assert isinstance(dm, hv.DynamicMap)
assert isinstance(over, hv.NdOverlay)
assert isinstance(crv, hv.Curve)
assert crv.kdims == [hv.Dimension('trace')]
assert crv.vdims == [hv.Dimension('value')]
bf = ht.buffer
assert len(bf.data) == 6
with exec.trace(ht):
exec.run(n_steps=2)
assert ht.buffer == bf
assert len(bf.data) == 3 * 6
ht = tr.take(6).to(sim.trace.Holotrace, skip=4, batch=5)
with exec.trace(ht):
exec.run()
print(ht.traces)
print(ht.data)
assert ht.data.shape == (6 * 5, 3)
assert ht.data.shape == (6 * 6, 3)
ht = tr.take(6).to(sim.trace.Holotrace, skip=4, batch=100, timeout=10)
with exec.trace(ht):
exec.run()
assert ht.data.shape == (0, 3)
assert ht.data.shape == (6 * 6, 3)
ht = tr.take(6).to(sim.trace.Holotrace, skip=4, batch=100, timeout=.001)
with exec.trace(ht):
exec.run()
assert ht.data.shape[0] > 0
assert ht.data.shape == (6 * 6, 3)
import pandas as pd
import hvplot.pandas
import holoviews as hv
from holoviews import opts
from holoviews import dim
hv.extension("bokeh")
def plot_stats_distribution(data: pd.DataFrame, plot_cols: list) -> hv.Layout:
hist_plots = {}
for col in plot_cols:
hist_plots[col] = data[col].hvplot.hist(
normed=True) * data[col].hvplot.kde()
stats_distribution = hv.Layout(list(hist_plots.values())).cols(1)
return stats_distribution
def plot_player_ratings_scatter(
player_ratings: pd.DataFrame,
x_col: str,
y_col: str,
color_col: str = "overall",
size_col: str = "overall",
**plot_opts,
) -> hv.Overlay:
scatter_base = (player_ratings.reset_index().hvplot.scatter(
x=x_col,
y=y_col,
c=color_col,
hover_cols=["name", "overall"],
_backends = ['plotly', 'bokeh', 'matplotlib']
# If the user selected a backend already, use it as defaults by activating it
# last
_curr_backend = hv.Store.current_backend
if _curr_backend:
_backends.remove(_curr_backend)
_backends.append(_curr_backend)
for backend in _backends:
try:
importlib.import_module(backend)
except Exception:
pass
else:
hv.extension(backend)
COLOR_CYCLE = [
'#377eb8', '#ff7f00', '#4daf4a', '#f781bf', '#a65628', '#984ea3',
'#999999', '#e41a1c', '#dede00'
]
"""
Colorblind-friendly cycle, see https://gist.github.com/thriveth/8560036
"""
plt.rcParams['axes.prop_cycle'] = make_cycler(color=COLOR_CYCLE)
class WrappingHBox(widgets.HBox):
"""
HBox that will overflow on multiple lines if the content is too large to
import parambokeh
import param
from colorcet import cm_n, fire
from bokeh.models import Slider, Button
from bokeh.layouts import layout
from bokeh.io import curdoc
from bokeh.models import WMTSTileSource
from holoviews.operation.datashader import datashade, aggregate, shade
shade.cmap = fire
hv.extension('bokeh')
renderer = hv.renderer('bokeh').instance(mode='server')
# Load data
ddf = dd.read_parquet(os.path.join(os.path.dirname(__file__),'..','..','..','data','nyc_taxi_wide.parq')).persist()
from bokeh.models import WMTSTileSource
url = 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{Z}/{Y}/{X}.jpg'
wmts = gv.WMTS(WMTSTileSource(url=url))
stream = hv.streams.Stream.define('HourSelect', hour=0)()
points = hv.Points(ddf, kdims=['dropoff_x', 'dropoff_y'])
dmap = hv.util.Dynamic(points, operation=lambda obj, hour: obj.select(dropoff_hour=hour).relabel('Hour of Day: %d' % hour),
streams=[stream])
# Apply aggregation
def plot():
#################################################################333333
# Final plot.
# High Significant
from shapely.geometry import Point, Polygon
import pandas as pd
import numpy as np
import geoviews as gv
import bokeh
import panel as pn
import holoviews as hv
from holoviews import opts
from holoviews.operation.datashader import datashade, rasterize
hv.extension("bokeh")
import math
from bokeh.models import HoverTool
from scipy.interpolate import griddata
from scipy.io import loadmat
import datetime
from dateutil.parser import parse
from datetime import timedelta
import time
strtt = time.time()
datamat = loadmat('IOEC_ECM_noDA_20190703_masked.mat')
# datamat = loadmat('IOEC_ECM_DA_20191121_masked.mat')
Xp = datamat['Xp']
Yp = datamat['Yp']
# Xp=np.where(((Xp>= 85) & (Xp<=88) & (Yp>=19) & (Yp<=22)),Xp,88)
# Yp=np.where(((Xp>= 85) & (Xp<=88) & (Yp>=19) & (Yp<=22)),Yp,22)
strt = datetime.datetime(2019, 7, 4, 0, 0)
end = datetime.datetime(2019, 1, 13, 0, 0)
from bokeh.models.callbacks import CustomJS
def perdelta(strt, end, delta):
curr = strt
while curr < end:
yield curr
curr += delta
# Read element file
tri_new = pd.read_csv('fort.ele',
delim_whitespace=True,
names=('A', 'B', 'C', 'D'),
usecols=[1, 2, 3],
skiprows=1,
dtype={'D': np.int})
dateList = []
def plotthis(datetime, regions='Whole_East_Coast'):
dat = datetime
# datetostr=result.strftime("%Y%b%d%H")
dt = parse(str(dat))
yr = dt.year
mn = dt.month
d = dt.day
hr = dt.hour
mi = dt.minute
if hr < 10:
hr = '0' + str(hr)
else:
d = str(d)
hr = str(hr)
if int(d) < 10:
d = '0' + str(d)
else:
d = str(d)
varname = 'Steepn_' + str(yr) + '0' + str(mn) + str(
d) + '_' + hr + '0000'
x = Xp.flatten()
y = Yp.flatten()
z = datamat[varname]
if regions is 'Odisha':
z = np.where(((Xp >= 85) & (Xp <= 88) & (Yp >= 19) & (Yp <= 22)),
z, np.nan).flatten()
elif regions is 'Andra_Pradesh':
z = np.where(((Xp >= 79) & (Xp <= 85) & (Yp >= 13) & (Yp <= 19)),
z, np.nan).flatten()
elif regions is 'Tamil_Nadu':
z = np.where(((Xp >= 77) & (Xp <= 83) & (Yp >= 7) & (Yp <= 14)), z,
np.nan).flatten()
elif regions is 'Whole_East_Coast':
z = z.flatten()
else:
# data = get_data4region(data,**odisha)
z = z.flatten()
# z = z.flatten()
Longitude = x
Latitude = y
HS = z
pts = np.stack((Longitude, Latitude, HS)).T
verts = pd.DataFrame(np.stack((Longitude, Latitude, HS)).T,
columns=['Longitude', 'Latitude', 'HS'])
# openStreet Background.
tri_sub = tri_new.apply(lambda x: x - 1)
ggpoints = gv.Points(verts, vdims=['HS'])
ggsubraster = rasterize(gv.TriMesh((tri_sub, gv.Points(verts))))
tri = gv.TriMesh((tri_sub, gv.Points(verts)))
return tri
allplot = {
(k.strftime("%Y-%m-%d %H:%M:%S"), r): plotthis(k, r)
for k in perdelta(strt, strt + timedelta(days=9), timedelta(hours=3))
for r in ['Odisha', 'Andra_Pradesh', 'Whole_East_Coast', 'Tamil_Nadu']
}
# allplot2={(k.strftime("%Y-%m-%d %H:%M:%S"),r):plotsecond(k,r)for k in perdelta(strt, strt + timedelta(days=1), timedelta(hours=18)) for r in ['Odisha','Andra_Pradesh','Whole_East_Coast','Tamil_Nadu']}
df_div = hv.Div("""
<figure>
<img src="https://i.ibb.co/S0t5GWb/imglogo.png" height='80' width='90' vspace='-10'>
""")
df_div1 = hv.Div("""
 <center><b><p style="color:#B22222";font-size:80px;font-family:Times new roman><h1 style=font-size:20px;margin-left:2.5em;margin-top:-1em;color:#B22222>Indian National Center for Ocean Information Services<br />
(INCOIS)</h1></p></b></center>
""")
df_div2 = hv.Div("""
<html>
<head>
<style>
input[type=button], input[type=submit], input[type=reset] {
background-color: #C6E2FF;
color: DARKVIOLET;
padding: 10px 22px;
text-decoration: none;
margin: 4px 2px;
cursor: pointer;
font-weight: bold;
font-size: 15px;
border: 2px solid light slateblue
}
</style>
</head>
<body>
<input type="button" value=" PRINT " onClick="window.print()">
</body>
</html>
""")
colorbar_opts = {
'major_label_overrides': {
0.00: '0.00',
0.02: '0.02',
0.04: '0.04',
0.06: '0.06',
0.08: '0.08',
0.10: '0.10',
0.12: '0.12',
0.14: '> 0.14',
0.15: '0.15',
0.16: ' ',
0.17: '>0.17',
},
'major_label_text_align': 'left',
'major_label_text_font_style': 'bold',
}
levels = [0.00, 0.02, 0.04, 0.06, 0.08, 0.10, 0.12, 0.14, 0.15, 0.16, 0.17]
def disable_logo(plot, element):
plot.state.toolbar.logo = None
hv.plotting.bokeh.ElementPlot.finalize_hooks.append(disable_logo)
def plot_limits(plot, element):
plot.handles['x_range'].min_interval = 100
plot.handles['x_range'].max_interval = 55000000
# 3000000
plot.handles['y_range'].min_interval = 500
plot.handles['y_range'].max_interval = 900000
opts = dict(
width=700,
height=700,
logz=False,
logx=False,
logy=False,
responsive=True,
active_tools=['wheel_zoom'],
tools=['save', 'wheel_zoom', 'hover'],
hooks=[plot_limits, disable_logo],
colorbar=True,
color_levels=15,
colorbar_opts=colorbar_opts,
cmap=[
'#000080',
'#0000cd',
'#0008ff',
'#004cff',
'#0090ff',
'#00d4ff',
'#29ffce',
'#60ff97',
'#97ff60',
'#ceff29',
'#ffe600',
'#ffa700',
# '#ff6800',
'#ff2900',
'#cd0000',
'#800000',
],
clim=(0.00, 0.15),
title="\t\t\t\t\t\t\t\t Wave Steepness . ",
fontsize={
'title': 18,
'xlabel': 15,
'ylabel': 15,
'ticks': 12
})
tiles = gv.tile_sources.Wikipedia
tiles = gv.tile_sources.Wikipedia
hmap1 = hv.HoloMap(
allplot, kdims=['Select Date and Time :', 'Select Indian States'])
# hmap2 = hv.HoloMap(allplot2, kdims=['Date and Time :','region'])
logo1 = hv.RGB.load_image("https://i.ibb.co/7VXRPCS/logo1.png")
def absolute_position(plot, element):
glyph = plot.handles['glyph']
x_range, y_range = plot.handles['x_range'], plot.handles['y_range']
glyph.dh_units = 'screen'
glyph.dw_units = 'screen'
glyph.dh = 60
glyph.dw = 90
# x_range.start=+85
# y_range.start=+20
glyph.x = x_range.start
glyph.y = y_range.start
xcode = CustomJS(code="glyph.x = cb_obj.start", args={'glyph': glyph})
plot.handles['x_range'].js_on_change('start', xcode)
ycode = CustomJS(code="glyph.y = cb_obj.start", args={'glyph': glyph})
plot.handles['y_range'].js_on_change('start', ycode)
# finalplot=tiles*rasterize(hmap1.redim.range(Latitude=(13, 19), Longitude=(79, 85))).options(**opts)*hmap2
dd = df_div.opts(width=90, height=80)
dd1 = df_div1.opts(width=600, height=90)
dd2 = df_div2.opts(width=100, height=10)
finalplot = pn.Column(
pn.Row(dd, dd1),
tiles * rasterize(hmap1).options(**opts) *
logo1.opts(hooks=[absolute_position], apply_ranges=False))
# print("--- %s seconds ---" % (time.time() - strtt))
from bokeh.embed import components
from bokeh.resources import CDN
from bokeh.io import curdoc
doc = curdoc()
script, div = components(finalplot.get_root(doc))
cdn_js0 = CDN.js_files[0]
cdn_js = CDN.js_files[1]
cdn_css = CDN.css_files
print("cdn_js:", cdn_js)
print("cdn_css", cdn_css)
return render_template("plot.html",
script=script,
div=div,
cdn_css=cdn_css,
cdn_js=cdn_js,
cdn_js0=cdn_js0)
