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)