def gen_real_view(self, resetting, x_range, y_range):
if x_range is None:
x_range = self.xrange
if y_range is None:
y_range = self.yrange0
# ipdb.set_trace()
if resetting:
return dynspread(datashade(self.real_curve,
cmap='blue',
normalization='linear',
x_range=self.xrange,
y_range=self.yrange0,
min_alpha=self.min_alpha,
dynamic=False),
max_px=max_px)
else:
return dynspread(datashade(self.real_curve,
cmap='blue',
normalization='linear',
x_range=x_range,
y_range=y_range,
min_alpha=self.min_alpha,
dynamic=False),
max_px=max_px)
def test_datashade_in_overlay_selection(self):
points = Points(self.data)
layout = points * dynspread(datashade(points))
lnk_sel = link_selections.instance(unselected_color='#ff0000')
linked = lnk_sel(layout)
current_obj = linked[()]
# Check base points layer
self.check_base_points_like(current_obj[()].Points.I, lnk_sel)
# Check selection layer
self.check_overlay_points_like(current_obj[()].Points.II, lnk_sel,
self.data)
# Check RGB base layer
self.assertEqual(
current_obj[()].RGB.I,
dynspread(
datashade(points, cmap=lnk_sel.unselected_cmap,
alpha=255))[()])
# Check RGB selection layer
self.assertEqual(
current_obj[()].RGB.II,
dynspread(datashade(points, cmap=lnk_sel.selected_cmap,
alpha=255))[()])
# Perform selection of second and third point
selectionxy = TestLinkSelections.get_value_with_key_type(
lnk_sel._selection_expr_streams,
hv.Points).input_streams[0].input_stream.input_streams[0]
self.assertIsInstance(selectionxy, SelectionXY)
selectionxy.event(bounds=(0, 1, 5, 5))
current_obj = linked[()]
# Check that base points layer is unchanged
self.check_base_points_like(current_obj[()].Points.I, lnk_sel)
# Check points selection layer
self.check_overlay_points_like(current_obj[()].Points.II, lnk_sel,
self.data.iloc[1:])
# Check that base RGB layer is unchanged
self.assertEqual(
current_obj[()].RGB.I,
dynspread(
datashade(points, cmap=lnk_sel.unselected_cmap,
alpha=255))[()])
# Check selection RGB layer
self.assertEqual(
current_obj[()].RGB.II,
dynspread(
datashade(points.iloc[1:],
cmap=lnk_sel.selected_cmap,
alpha=255))[()])
def test_datashade_selection(self):
scatter = hv.Scatter(self.data, kdims='x', vdims='y')
layout = scatter + dynspread(datashade(scatter))
lnk_sel = link_selections.instance()
linked = lnk_sel(layout)
current_obj = linked[()]
# Check base scatter layer
self.check_base_scatter_like(current_obj[0][()].Scatter.I, lnk_sel)
# Check selection layer
self.check_overlay_scatter_like(current_obj[0][()].Scatter.II, lnk_sel,
self.data)
# Check RGB base layer
self.assertEqual(
current_obj[1][()].RGB.I,
dynspread(
datashade(scatter, cmap=lnk_sel.unselected_cmap,
alpha=255))[()])
# Check RGB selection layer
self.assertEqual(
current_obj[1][()].RGB.II,
dynspread(datashade(scatter, cmap=lnk_sel.selected_cmap,
alpha=0))[()])
# Perform selection of second and third point
boundsxy = lnk_sel._selection_expr_streams[0]._source_streams[0]
self.assertIsInstance(boundsxy, hv.streams.BoundsXY)
boundsxy.event(bounds=(0, 1, 5, 5))
current_obj = linked[()]
# Check that base scatter layer is unchanged
self.check_base_scatter_like(current_obj[0][()].Scatter.I, lnk_sel)
# Check scatter selection layer
self.check_overlay_scatter_like(current_obj[0][()].Scatter.II, lnk_sel,
self.data.iloc[1:])
# Check that base RGB layer is unchanged
self.assertEqual(
current_obj[1][()].RGB.I,
dynspread(
datashade(scatter, cmap=lnk_sel.unselected_cmap,
alpha=255))[()])
# Check selection RGB layer
self.assertEqual(
current_obj[1][()].RGB.II,
dynspread(
datashade(scatter.iloc[1:],
cmap=lnk_sel.selected_cmap,
alpha=255))[()])
def _get_points(self):
embeddings = self.embeddings
classes = self.classes
if (self.label_flag) and (classes is not None):
data = pd.DataFrame(embeddings)
data.columns = ['ivis 1', 'ivis 2']
data['label'] = classes
num_ks = len(np.unique(classes))
color_key = list(enumerate(Sets1to3[0:num_ks]))
embed = {
k: hv.Points(data.values[classes == k, :],
['ivis 1', 'ivis 2'],
'k',
label=str(k)).opts(color=v, size=0)
for k, v in color_key
}
dse = dynspread(
datashade(hv.NdOverlay(embed, kdims=['k']),
aggregator=ds.by('k', ds.count())))
color_points = hv.NdOverlay({
k: hv.Points([0, 0]).opts(color=v, size=0)
for k, v in color_key
})
points = color_points * dse
else:
points = datashade(hv.Points(embeddings))
points.opts(height=400, width=500, xaxis=None, yaxis=None)
return points
def view(self):
if datashaded and self.nodeCount > 1:
plot = dynspread(
datashade(self.plot,
normalization='linear',
width=self.size,
height=self.size,
cmap=self.colorMap[self.color_palette]))
self.points.opts(cmap=self.colorMap[self.color_palette],
color=self.node_color,
size=self.node_size)
return (plot, self.points)
else:
if (min(self.plot.data['weight']) < max(
self.plot.data['weight'])):
self.points.opts(cmap=self.colorMap[self.color_palette],
color=self.node_color,
size=self.node_size)
self.plot.opts(
edge_cmap=self.colorMap[self.color_palette],
edge_color='weight',
edge_line_width=dim('weight').norm() * 5 + 0.1,
edge_line_alpha=0.1 + dim('weight').norm() * 0.9)
else:
self.points.opts(cmap=self.colorMap[self.color_palette],
color=self.node_color,
size=self.node_size)
self.plot.opts(edge_cmap=self.colorMap[self.color_palette],
edge_color=dim('weight'),
edge_line_width=dim('weight') * 3,
edge_line_alpha=dim('weight'))
return (self.plot, self.points)
def _process(self, element, key=None):
vdim = self.p.vdim
if self.p.aggregator == 'mean':
aggregator = ds.mean(vdim)
elif self.p.aggregator == 'std':
aggregator = ds.std(vdim)
elif self.p.aggregator == 'count':
aggregator = ds.count()
kwargs = dict(cmap=cc.palette[self.p.cmap], aggregator=aggregator)
if self.p.width is not None:
kwargs.update(width=self.p.width,
height=self.p.height,
streams=[hv.streams.RangeXY])
datashaded = dynspread(datashade(element, **kwargs))
# decimate_opts = dict(plot={'tools':['hover', 'box_select']},
# style={'alpha':0, 'size':self.p.decimate_size,
# 'nonselection_alpha':0})
# decimated = decimate(element, max_samples=self.p.max_samples).opts(**decimate_opts)
return datashaded # * decimated
def make_view(self, x_range=None, y_range=None, **kwargs):
#map_tiles = tiles.opts(style=dict(alpha=self.alpha), plot=options)
points = hv.Points(
df,
kdims=['X_CORD', 'Y_CORD'],
vdims=['EVENT_COUNT', 'EventType', 'SUB', 'day', 'FEEDER_ID'])
if (self.BySUB & self.ByFeeder & self.ByDay):
selected = points.select(EventType=self.plot,
EVENT_COUNT=self.numEvents,
SUB=self.Substations,
day=self.DayNum,
FEEDER_ID=self.Feeder)
elif (self.BySUB & self.ByFeeder & (not self.ByDay)):
selected = points.select(EventType=self.plot,
EVENT_COUNT=self.numEvents,
SUB=self.Substations,
FEEDER_ID=self.Feeder)
elif (self.BySUB & (not self.ByFeeder) & self.ByDay):
selected = points.select(EventType=self.plot,
EVENT_COUNT=self.numEvents,
SUB=self.Substations,
day=self.DayNum)
elif (self.BySUB & (not self.ByFeeder) & (not self.ByDay)):
selected = points.select(EventType=self.plot,
EVENT_COUNT=self.numEvents,
SUB=self.Substations)
elif ((not self.BySUB) & self.ByFeeder & self.ByDay):
selected = points.select(EventType=self.plot,
EVENT_COUNT=self.numEvents,
day=self.DayNum,
FEEDER_ID=self.Feeder)
elif ((not self.BySUB) & self.ByFeeder & (not self.ByDay)):
selected = points.select(EventType=self.plot,
EVENT_COUNT=self.numEvents,
FEEDER_ID=self.Feeder)
elif ((not self.BySUB) & (not self.ByFeeder) & self.ByDay):
selected = points.select(EventType=self.plot,
EVENT_COUNT=self.numEvents,
day=self.DayNum)
else:
selected = points.select(EventType=self.plot,
EVENT_COUNT=self.numEvents)
SagSwellPts = datashade(selected,
x_sampling=1,
y_sampling=1,
cmap=self.colormap,
dynamic=False,
x_range=x_range,
y_range=y_range,
width=640,
height=380)
dsss = dynspread(SagSwellPts,
shape='circle',
max_px=self.maxpix,
threshold=self.threshhold)
#return map_tiles * dsss
return dsss
def scatter_dist_by_mappings(dataset, x_kdims, y_kdims,
mappings,
selection_dim="Gene",
datashade_=False,
dynspread_=False,
):
data_groups = {name: dataset.sel({selection_dim: genes}) for name, genes in mappings.items()}
data_group_dfs = {k: v[[x_kdims, y_kdims]].to_dataframe() for k, v in data_groups.items()}
points = {k: hv.Points(val, kdims=[x_kdims, y_kdims]) for k, val in data_group_dfs.items()}
dist_x = {k: univariate_kde(hv.Distribution(p, kdims=[y_kdims], group="dist_x"), n_samples=1000)
for k, p in points.items()}
dist_y = {k: univariate_kde(hv.Distribution(p, kdims=[x_kdims], group="dist_y"), n_samples=1000)
for k, p in points.items()}
if datashade_:
points_overlay = datashade(hv.NdOverlay(points))
if dynspread_:
points_overlay = dynspread(points_overlay)
else:
points_overlay = hv.NdOverlay(points)
return points_overlay << hv.NdOverlay(dist_x) << hv.NdOverlay(dist_y)
def shade(hv_obj, reduction='any', color=None, spread=False):
"""
Apply datashading to a holoviews object.
hv_obj: a holovies object like Curve, Scatter, etc.
reduction: Most common will be 'any' and 'count'.
Supply any name here to see list of valid reductions
color: Mostly used for 'any' aggregation to specify a color
spread: Smear out points slightly bigger than 1 pixel for easier
visibility
"""
import datashader as ds
from holoviews.operation.datashader import datashade, dynspread
if reduction not in ALLOWED_REDUCTIONS:
raise ValueError(
'Allowed reductions are {}'.format(ALLOWED_REDUCTIONS))
reducer = getattr(ds.reductions, reduction)
kwargs = dict(aggregator=reducer())
if color is None and reduction == 'any':
kwargs.update(cmap=['blue'])
else:
kwargs.update(cmap=[color])
obj = datashade(hv_obj, **kwargs)
if spread:
obj = dynspread(obj)
return obj
def make_scatter(self, object_type, x_range=None, y_range=None, **kwargs):
self._set_data(**kwargs)
logging.info('x_range={}, y_range={}'.format(x_range, y_range))
if object_type == 'all':
dset = self.ds
else:
dset = self.ds.select(label=object_type)
pts = dset.to(hv.Points, kdims=['x', 'y'], vdims=['label'], groupby=[])
print(pts.dimensions())
scatter = dynspread(
datashade(pts,
x_range=x_range,
y_range=y_range,
dynamic=False,
normalization='log'))
hover = HoverTool(tooltips=[("(x,y)", "($x, $y)")])
# hv.opts({'RGB': {'plot' : {'tools' : [hover]}}}, scatter)
# scatter = scatter.opts(plot=dict(tools=[hover]))
title = '{} ({}) {}'.format(object_type, len(dset),
pts.get_dimension('y').label)
scatter = scatter.opts('RGB [width=600, height=400]').relabel(title)
return scatter
def plot_performance(ds_preds, full=False):
"""Multiple plots using xr_preds"""
p = hv_plot_prediction(ds_preds.isel(t_source=10))
display(p)
n = len(ds_preds.t_source)
d_ahead = ds_preds.mean(['t_source'])['nll'].groupby('t_ahead_hours').mean()
nll_vs_tahead = (hv.Curve(
(d_ahead.t_ahead_hours,
d_ahead)).redim(x='hours ahead',
y='nll').opts(
title=f'NLL vs time ahead (no. samples={n})'))
display(nll_vs_tahead)
# Make a plot of the NLL over time. Does this solution get worse with time?
if full:
d_source = ds_preds.mean(['t_ahead'])['nll'].groupby('t_source').mean()
nll_vs_time = (hv.Curve(d_source).opts(
title='Error vs time of prediction'))
display(nll_vs_time)
# A scatter plot is easy with xarray
if full:
tlim = (ds_preds.y_true.min().item(), ds_preds.y_true.max().item())
true_vs_pred = datashade(hv.Scatter(
(ds_preds.y_true,
ds_preds.y_pred))).redim(x='true', y='pred').opts(width=400,
height=400,
xlim=tlim,
ylim=tlim,
title='Scatter plot')
true_vs_pred = dynspread(true_vs_pred)
true_vs_pred
display(true_vs_pred)
def __call__(self, dset, **params):
self.p = ParamOverrides(self, params)
if self.p.vdim is None:
vdim = dset.vdims[0].name
else:
vdim = self.p.vdim
pts = hv.util.Dynamic(dset, operation=skypoints,
streams=[self.p.filter_stream])
if self.p.aggregator == 'mean':
aggregator = ds.mean(vdim)
elif self.p.aggregator == 'std':
aggregator = ds.std(vdim)
elif self.p.aggregator == 'count':
aggregator = ds.count()
decimate_opts = dict(plot={'tools': ['hover',
'box_select']},
style={'alpha': 0,
'size': self.p.decimate_size,
'nonselection_alpha': 0})
decimated = decimate(pts).opts(**decimate_opts)
raster_ = rasterize(pts, aggregator=aggregator)
color_gadget = raster_.opts(cmap=Viridis[256], colorbar=True, alpha=0)
sky_shaded = shade(raster_, cmap=viridis)
plot = dynspread(sky_shaded) * decimated * color_gadget
return plot.options(bgcolor="black", responsive=True, min_height=100)
def hv_plot(G, layout='circular', method='bokeh', name='', kwargs=opts):
'''
Returns graph plot using HoloViews wrapper for bokeh.
Optionally, draws edges using datashade functions.
Accepted vars:
G => networkx.Graph() object
layout => circular; forceatlas2; random
method => bokeh; datashader
name => graph title or label
kwargs => optionals
'''
hv.extension("bokeh")
nodes, edges = nx_layout(G)
# apply parameters
if kwargs:
hv.opts.defaults(
hv.opts.EdgePaths(**kwargs),
hv.opts.Graph(**kwargs),
hv.opts.Nodes(**kwargs))
# plot edges with bokeh
circle = hv.Graph(edges, label=name).opts(style=dict(node_size=10))
# plot edges with datashader (WIP)
if method == 'datashader':
hnodes = circle.nodes.opts(style=dict(size=10))
dscirc = (hd.dynspread(hd.datashade(circle))*hnodes).relabel(name)
return dscirc
return circle
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 make_view(self, x_range=None, y_range=None, **kwargs):
#map_tiles = tiles.opts(style=dict(alpha=self.alpha), plot=options)
hvmap = projected_gv.select(z=self.altitude, k=self.trackrange)
dsmap = datashade(hvmap, x_sampling=1, y_sampling=1, cmap=self.colormap,
dynamic=False, x_range=x_range, y_range=y_range)
gv_options = {'bgcolor':'black', 'show_grid':True}
gvmap = dynspread(dsmap.opts(plot=gv_options))
return gvmap #* hv.util.Dynamic(aggregate(hvmap, width=5, height=5, streams=[PointerX]), operation=hv.QuadMesh)
def z_y_views(self, x_range, y_range):
x_min = x_range[0]; x_max = x_range[1]
y_min = y_range[0]; y_max = y_range[1]
datas = projected_gv.select(x=x_range, y=y_range, z=self.altitude, k=self.trackrange).to(hv.Dataset)
hvmap = datas.to(hv.Points, kdims=self.plotdims, vdims=['i', 'k'], groupby=[])
dsmap = datashade(hvmap, cmap=self.colormap, dynamic=False, x_range=x_range, y_range=y_range)
gv_options = {'bgcolor':'black', 'show_grid':True}
gvmap = dynspread(dsmap.opts(plot=gv_options))
return gvmap
def datashade(self, column=None, reduction=None):
"""Return datashader shaded with reduction of given column value
Arguments:
- `column`:
- `reduction`:
"""
import datashader as ds
from bokeh import palettes
from holoviews.operation.datashader import aggregate, shade, datashade, dynspread
if reduction is None:
reduction = ds.mean
#print "datashade", column, reduction
shade_opts = {"cmap": palettes.inferno(64)}
if column is not None:
d = self._points.dframe()[column]
d_min, d_max = d.min(), d.max()
#print "Value Range:", d_min, d_max
#shade_opts["clims"] = (d_min, d_max)
if d_min * d_max < 0.0:
print("Diverging palette")
d_extreme = max(-d_min, d_max)
shade_opts = {
"cmap": palettes.RdYlBu11,
#"clims": (-d_extreme, d_extreme)
}
def _linear_norm_debug(v, masked):
import pandas as pd
#print args
#print kwargs
print(v)
print(pd.DataFrame(v).describe())
min_v, max_v = v[~masked].min(), v[~masked].max()
print(min_v, max_v)
o = (v - min_v) / (max_v - min_v)
print(o)
return o
#del (shade_opts["clims"])
plot = dynspread(
datashade(
self._points,
aggregator=ds.count() if column is None else reduction(column),
normalization="linear" if "clims" in shade_opts else "eq_hist",
**shade_opts))
return plot
def plot_df(df_list):
renderer = hv.renderer('bokeh').instance(mode='server')
print(df_list)
lines = {
i: hv.Curve(df_list[i], kdims=['x'], vdims=['y'])
for i in range(len(df_list))
}
linespread = dynspread(datashade(hv.NdOverlay(lines, kdims='k')),
aggregator=ds.count_cat('k')).opts(
**{'plot': {
'height': 400,
'width': 1400
}})
return renderer.get_plot(linespread).state
def test_datashade_curve(self):
rgb = dynspread(datashade(self.ds.to(Curve, 'a', 'b', groupby=[]),
dynamic=False),
dynamic=False)
rgb2 = dynspread(datashade(self.ds2.to(Curve, 'a', 'b', groupby=[]),
dynamic=False),
dynamic=False)
self.assertNotEqual(rgb, rgb2)
# Check dataset
self.assertEqual(rgb.dataset, self.ds)
# Check pipeline
ops = rgb.pipeline.operations
self.assertEqual(len(ops), 4)
self.assertIs(ops[0].output_type, Dataset)
self.assertIs(ops[1].output_type, Curve)
self.assertIsInstance(ops[2], datashade)
self.assertIsInstance(ops[3], dynspread)
# Execute pipeline
self.assertEqual(rgb.pipeline(rgb.dataset), rgb)
self.assertEqual(rgb.pipeline(self.ds2), rgb2)
def gen_imag_view(self, resetting, x_range, y_range):
if x_range is None:
x_range = self.xrange
if y_range is None:
y_range = self.yrange1
if resetting:
return dynspread(datashade(self.imag_curve,
cmap='red',
normalization='linear',
x_range=self.xrange,
y_range=self.yrange1,
min_alpha=self.min_alpha,
dynamic=False),
max_px=max_px)
else:
return dynspread(datashade(self.imag_curve,
cmap='red',
normalization='linear',
x_range=x_range,
y_range=y_range,
min_alpha=self.min_alpha,
dynamic=False),
max_px=max_px)
def querygraph(gene, set):
if (set == "microglia"):
categorical_points = hv.Points(
(df3["UMAP_1"], df3["UMAP_2"], getVals_microglia(gene)),
['UMAP_1', 'UMAP_2'],
vdims='Category')
else:
categorical_points = hv.Points(
(df["UMAP_1"], df["UMAP_2"], getVals(gene)), ['UMAP_1', 'UMAP_2'],
vdims='Category')
return dynspread(
datashade(categorical_points,
aggregator=ds.count_cat('Category'),
color_key=['#c9c9c9', '#00008a'],
dynamic=False).opts(plot=dict(width=600, height=450)))
def clustersgraph(set):
if (set == "microglia"):
categorical_points = hv.Points(
(df3["UMAP_1"], df3["UMAP_2"], df4["SCT_snn_res.0.2"]),
['UMAP_1', 'UMAP_2'],
vdims='Category')
else:
categorical_points = hv.Points(
(df["UMAP_1"], df["UMAP_2"], df2["SCT_snn_res.0.2"]),
['UMAP_1', 'UMAP_2'],
vdims='Category')
return dynspread(
datashade(categorical_points,
aggregator=ds.count_cat('Category'),
color_key=Sets1to3,
dynamic=False).opts(plot=dict(width=600, height=450)))
def plot_map(data, label, agg_data, agg_name, cmap):
url = "http://server.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Base/MapServer/tile/{Z}/{Y}/{X}.png"
geomap = gv.WMTS(url)
points = hv.Points(gv.Dataset(data, kdims=['x', 'y'], vdims=[agg_name]))
agg = datashade(points,
element_type=gv.Image,
aggregator=agg_data,
cmap=cmap)
zip_codes = dynspread(agg, threshold=T, max_px=PX)
hover = hv.util.Dynamic(rasterize(points,
aggregator=agg_data,
width=50,
height=25,
streams=[RangeXY]),
operation=hv.QuadMesh)
hover = hover.options(cmap=cmap)
img = geomap * zip_codes * hover
img = img.relabel(label)
return img
def hv_scatter_dist(dataset, x_kdims, y_kdims,
datashade_=False,
dynspread_=False):
if dynspread_ and not datashade_:
warnings.warn("Dynspread can only be used with datashade, setting both to true.")
datashade_ = True
df = dataset[[x_kdims, y_kdims]].to_dataframe()
points = hv.Points(df, kdims=[x_kdims, y_kdims])
dist_x = univariate_kde(hv.Distribution(points, kdims=[y_kdims], group="dist_x"), n_samples=1000)
dist_y = univariate_kde(hv.Distribution(points, kdims=[x_kdims], group="dist_y"), n_samples=1000)
if datashade_:
points = datashade(points)
if dynspread_:
points = dynspread(points)
return points << dist_x << dist_y
def _process(self, element, key=None):
vdim = self.p.vdim
if self.p.aggregator == "mean":
aggregator = ds.mean(vdim)
elif self.p.aggregator == "std":
aggregator = ds.std(vdim)
elif self.p.aggregator == "count":
aggregator = ds.count()
kwargs = dict(cmap=list(cc.palette[self.p.cmap]),
aggregator=aggregator)
datashaded = dynspread(datashade(element, **kwargs))
# decimate_opts = dict(plot={'tools':['hover', 'box_select']},
# style={'alpha':0, 'size':self.p.decimate_size,
# 'nonselection_alpha':0})
# decimated = decimate(element, max_samples=self.p.max_samples).opts(**decimate_opts)
return datashaded.options(responsive=True, height=300) # * decimated
def make_sky(self,
object_type,
ra_range=None,
dec_range=None,
x_range=None,
y_range=None,
**kwargs):
if object_type == 'all':
dset = self.ds
else:
dset = self.ds.select(label=object_type)
if x_range is not None and y_range is not None:
dset = dset.select(x=x_range, y=y_range)
self._selected = dset.data.id
pts = dset.to(hv.Points, kdims=['ra', 'dec'], vdims=['y'], groupby=[])
agg = aggregate(pts,
width=100,
height=100,
x_range=ra_range,
y_range=dec_range,
aggregator=ds.mean('y'),
dynamic=False)
hover = hv.QuadMesh(agg).opts(
'[tools=["hover"]] (alpha=0 hover_alpha=0.2)')
shaded = dynspread(
datashade(pts,
x_range=ra_range,
y_range=dec_range,
dynamic=False,
cmap=cc.palette['coolwarm'],
aggregator=ds.mean('y')))
shaded = shaded.opts('RGB [width=400, height=400]')
return (shaded * hover).relabel('{} ({})'.format(
object_type, len(dset)))
def plotter_datashade(df, width, bacterium):
'''plots frames and areas of bacteria'''
# wants to handle large sets of data using datashade,
# not a lot of overlap, no need for points to be miniscule
# dynspread stretches points
dynspread.max_px = 9
dynspread.threshold = .8
points = hv.Points(
data=df,
kdims=["frame", "areas (μm^2)"],
)
p = hv.operation.datashader.datashade(
points,
cmap=bokeh.palettes.Blues8,
).opts(
width=width,
height=300,
padding=0.1,
show_grid=True,
).opts(title=bacterium)
return dynspread(p)
def __call__(self, dset, **params):
self.p = ParamOverrides(self, params)
if self.p.vdim is None:
vdim = dset.vdims[0].name
else:
vdim = self.p.vdim
pts = hv.util.Dynamic(dset,
operation=skypoints,
streams=[self.p.filter_stream])
if self.p.aggregator == 'mean':
aggregator = ds.mean(vdim)
elif self.p.aggregator == 'std':
aggregator = ds.std(vdim)
elif self.p.aggregator == 'count':
aggregator = ds.count()
kwargs = dict(cmap=cc.palette[self.p.cmap], aggregator=aggregator)
if self.p.width is not None:
kwargs.update(width=self.p.width, height=self.p.height)
# streams=[hv.streams.RangeXY])
decimate_opts = dict(plot={'tools': ['hover', 'box_select']},
style={
'alpha': 0,
'size': self.p.decimate_size,
'nonselection_alpha': 0
})
decimated = decimate(pts).opts(**decimate_opts)
sky_shaded = datashade(pts, **kwargs)
return dynspread(sky_shaded) * decimated
def plot_records_2d(records, to_pe, t_reference, width=600, time_stream=None):
"""Plot records in a dynamic 2D histogram of (time, pmt)
:param width: Plot width in pixels
:param time_stream: holoviews rangex stream to use. If provided,
we assume records is already converted to points (which hopefully
is what the stream is derived from)
"""
if time_stream is None:
# Records are still a dataframe, convert it to points
records, time_stream = _records_to_points(records=records,
to_pe=to_pe,
t_reference=t_reference)
# TODO: weigh by area?
return datashader.dynspread(
datashader.datashade(
records, y_range=(0, nEXO_strax.n_tpc_pmts),
streams=[time_stream])).opts(plot=dict(
width=width,
tools=[x_zoom_wheel(), 'xpan'],
default_tools=['save', 'pan', 'box_zoom', 'save', 'reset'],
show_grid=False))
if sample_fraction < 1:
df1.sample(frac=sample_fraction)
df1[['id']] = df1[['id']].astype(long)
df1 = df1.sort_values(by=['xi'], ascending=[False])
df = df.append(df1, ignore_index=True)
print('\nDone.')
df['pr_MeV'] = df['pr']*0.511
df['pz_MeV'] = df['pz']*0.511
xi_r = hv.Points(df[['xi', 'r']])
xi_pz = hv.Points(df[['xi', 'pz_MeV']])
xi_pr = hv.Points(df[['xi', 'pr_MeV']])
plot_1 = (dynspread(datashade(xi_r)) + dynspread(datashade(xi_pz)) +
dynspread(datashade(xi_pr))).cols(1)
renderer = hv.renderer('matplotlib').instance(fig='svg', holomap='gif')
renderer.save(plot_1, 'example_I', style=dict(Image={'cmap':'jet'}))
# pr_r = hv.Points(df[['pr_MeV', 'r']])
# pr_pz = hv.Points(df[['pr_MeV', 'pz_MeV']])
#
# (dynspread(datashade(xi_r)) + dynspread(datashade(pr_r))).cols(2)
# (dynspread(datashade(xi_pz)) + dynspread(datashade(pr_pz))).cols(2)
