def plot_sensitivities(df_tidy, name = 'H', logx = True, plot_abs = False, param = 'N'): df_tidy_n = df_tidy.loc[df_tidy['species'] == name, :] plots = [] for sense in [param, 'gamma']: df_small = df_tidy_n.loc[df_tidy_n['sensitivity_to'] == sense, :] if plot_abs: df_small['abs_sensitivity'] = np.abs(df_small['sensitivity'].values) points = hv.Points( data=df_small, kdims=[param, 'abs_sensitivity'], vdims=['gamma'], ) else: points = hv.Points( data=df_small, kdims=[param, 'sensitivity'], vdims=['gamma'], ) points.opts(color = 'gamma', cmap = 'Purples', logx = logx, title = sense, colorbar = True, size= 7, frame_height=200, frame_width=200 * 3 // 2,) p = hv.render(points) plots.append(p) return plots
def focus_plot(self, left_x, bottom_y, right_x, top_y, index, Counts): from holoviews import streams import holoviews as hv e = self._posxy._dataset d = [] if len(index) == 0 or left_x is None or bottom_y is None or len( index) > 100000: p = hv.Points(e.reset_index().head(0), kdims=self._data.coord_dims, vdims=["Sequence"] + self._data.data_dims, label="%d sequences" % (len(e))) else: d = e.iloc[index] p = hv.Points(d.reset_index(), kdims=self._data.coord_dims, vdims=["Sequence"] + self._data.data_dims, label="%d sequences" % (len(d))) self.zoom_selection.reset() p = p.opts(plot=dict(color_index=Counts, tools=["hover", "lasso_select", "box_select"], width=400, height=400)) #return p.hist(dimension=Counts, adjoin=False) #print(p.dframe().head()) return p p = p.hist(dimension="MeanFold", adjoin=False) print(p) return p
def test_record_selections(self): arr2 = np.random.rand(4, 3, 2) cube = xr.DataArray(arr2, dims=['a', 'b', 'c'], coords={ 'a': [1, 2, 3, 4], 'b': [1, 2, 3], 'c': [1, 2] }) cube.M.selected_zeros() bounds = [0, 0, 5, 5] points = hv.Points(np.array([[0, 0], [1, 1], [1, 0]]), kdims=['c', 'b']) res = cube.visualize._record_selections(bounds=bounds, points=points) exp_res = pd.DataFrame(columns=['b', 'c'], data=[[0, 0], [0, 1], [1, 1]]) self.assertTrue((exp_res == res).all) points = hv.Points(np.array([]), kdims=['c', 'b']) res = cube.visualize._record_selections(bounds=bounds, points=points) self.assertTrue((exp_res == res).all) bounds = (0, 0, 10, 10) cube.M.selected_zeros() points = hv.Points(np.array([]), kdims=['c', 'b']) exp_res = pd.DataFrame(columns=['b', 'c'], data=[]) res = cube.visualize._record_selections(bounds=bounds, points=points) self.assertTrue((exp_res == res).all)
def __init__(self, data): """ Arguments: - `data`: an object with attribute "embedding" e.g. TsneMapper() """ self._data = data if len(self._data.data_dims) == 0: self._points = hv.Points( self._data.embedding.reset_index(), #tsne.embedding.reset_index(), kdims=self._data.coord_dims, vdims=["Sequence"] + self._data.data_dims, label="Sequences", ) else: overlay_dict = {} for d in self._data.data_dims: p = hv.Points(self._data.embedding[self._data.coord_dims + [d]].rename(columns={ d: "Value" }).reset_index(), kdims=self._data.coord_dims, vdims=["Sequence", "Value"], label="Sequences") overlay_dict[d] = p #.opts(plot={"color_index"=d}) #self._points = hv.NdOverlay(overlay_dict, kdims=["Counts"]) self._points = hv.HoloMap(overlay_dict, kdims=["Counts"])
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 plot_observ_func(self, bin): plot_list = [] plot_aspect = 10 sel_observ = self.observ.query('dec_bin == @bin') sel_plot_observ = sel_observ.get_distribution_view() sel_max_observ = sel_plot_observ.max().max() sel_pos = sel_observ['position'] sel_like = self.likelihoods.query('dec_bin == @bin') sel_plot_like = sel_like.get_distribution_view() sel_max_like = sel_plot_like.max().max() sel_post = self.posteriors.query('dec_bin == @bin') sel_plot_post = sel_post.get_distribution_view() sel_max_post = sel_plot_post.max().max() sel_post_prev = self.posteriors.query('dec_bin == @bin-1') sel_plot_post_prev = sel_post_prev.get_distribution_view() sel_max_post_prev = sel_plot_post_prev.max().max() for ii in range(len(sel_observ)): sel = sel_plot_observ.iloc[ii] plot_list.append( hv.Curve(sel, vdims='observ', label=str(ii)).opts(labelled=['y'], ylim=(0, sel_max_observ))) plot_list.append( hv.Points((sel_pos.iloc[ii], [sel_max_observ / 10]))) if len(sel_observ) == 0: plot_list.append( hv.Curve([0, 0], vdims='observ', label='N/A').opts(labelled=['y'], ylim=(0, sel_max_observ), xaxis=None)) plot_list.append( hv.Points((sel_like['position'], [0]), vdims='observation')) like_plot = (hv.Curve(sel_plot_like.iloc[0], vdims='like').opts(labelled=['y'], ylim=(0, sel_max_observ), xaxis=None)) post_overlay = ( hv.Curve(sel_plot_post.iloc[0], vdims='post', label='cur') * hv.Curve(sel_plot_post_prev.iloc[0], vdims='post', label='prev')) return (hv.Overlay( plot_list, label=f'Spks: {len(sel_observ)} ({self.indic_str})').opts( aspect=plot_aspect) + like_plot + post_overlay).cols(1).opts( hv.opts.Curve(framewise=True, xlim=(0, None), ylim=(0, None), yformatter=self.yfmt, aspect=plot_aspect, yticks=2), hv.opts.Points(framewise=True, xlim=(0, None), ylim=(0, None), yformatter=self.yfmt, aspect=plot_aspect, yticks=2))
def hv_paths(a, b, c, d): diag_1 = hv.Path([np.c_[loop.values[a, :], loop.values[c, :]].T]).options(opts_path_1) diag_2 = hv.Path([np.c_[loop.values[b, :], loop.values[d, :]].T]).options(opts_path_2) point_1 = ((loop.values[a, :] + loop.values[c, :]) / 2) point_2 = ((loop.values[b, :] + loop.values[d, :]) / 2) diag_1_point = hv.Points((point_1[0], point_1[1])).options(opts_point_1) diag_2_point = hv.Points((point_2[0], point_2[1])).options(opts_point_2) return diag_1 * diag_2 * diag_1_point * diag_2_point
def tap_points(self, left_x, bottom_y, right_x, top_y, index): #def tap_points(self, **kwargs): if left_x is None: return hv.Points(([], [])) #return hv.Table(e.head(0).reset_index()) p = hv.Points(([left_x, left_x, right_x, right_x], [bottom_y, top_y, top_y, bottom_y])).opts(style=dict(color="red")) return p
def _create_hvplot(): # Generate some data cl1 = np.random.normal(loc=2, scale=0.2, size=(200, 200)) cl2x = np.random.normal(loc=-2, scale=0.6, size=200) cl2y = np.random.normal(loc=-2, scale=0.1, size=200) cl3 = np.random.normal(loc=0, scale=1.5, size=(400, 400)) # Create an overlay of points and ellipses clusters = (hv.Points(cl1).opts(color="blue") * hv.Points( (cl2x, cl2y)).opts(color="green") * hv.Points(cl3).opts(color="#FDDC22")) plot = clusters * hv.Ellipse(2, 2, 2) * hv.Ellipse(-2, -2, (4, 2)) return plot
def LocationThresh_View(examples, video_dict, reference, crop, tracking_params, stretch): #load video cap = cv2.VideoCapture(video_dict['fpath']) cap_max = int(cap.get(7)) #get max frames. 7 is index of total frames cap_max = int( video_dict['end']) if video_dict['end'] is not None else cap_max #examine random frames images = [] for example in range(examples): #analyze frame frm = np.random.randint(video_dict['start'], cap_max) #select random frame cap.set(1, frm) #sets frame to be next to be grabbed ret, dif, com, frame = Locate( cap, crop, reference, tracking_params) #get frame difference from reference #plot original frame image_orig = hv.Image( (np.arange(frame.shape[1]), np.arange(frame.shape[0]), frame)) image_orig.opts(width=int(reference.shape[1] * stretch['width']), height=int(reference.shape[0] * stretch['height']), invert_yaxis=True, cmap='gray', toolbar='below', title="Frame: " + str(frm)) orig_overlay = image_orig * hv.Points(([com[1]], [com[0]])).opts( color='red', size=20, marker='+', line_width=3) #plot heatmap dif = dif * (255 // dif.max()) image_heat = hv.Image( (np.arange(dif.shape[1]), np.arange(dif.shape[0]), dif)) image_heat.opts(width=int(dif.shape[1] * stretch['width']), height=int(dif.shape[0] * stretch['height']), invert_yaxis=True, cmap='jet', toolbar='below', title="Frame: " + str(frm)) heat_overlay = image_heat * hv.Points(([com[1]], [com[0]])).opts( color='red', size=20, marker='+', line_width=3) images.extend([orig_overlay, heat_overlay]) cap.release() layout = hv.Layout(images) return layout
def plot_closest(x, y): vdims = list(stocks.columns) if (x is None or y is None): return hv.Points([], vdims=vdims) opt = find_best_allocation(x, y) weights = opt.x ret, vol, _ = get_ret_vol_sr(weights) return hv.Points([(vol, ret, *weights)], ['Volatility', 'Return'], vdims=vdims, label='Current Portfolio').opts(color='green', size=10, line_color='black', tools=['hover'])
def event_selection(self): if not self.selection_spaces: return hv.Points(dset, ["cs1", "cs2"]).opts(color="blue") colors = hv.Cycle('Category10').values plots = [ hv.Points(dset, dims).opts(color=c) for c, dims in zip(colors, self.selection_spaces) ] layout = hv.Layout(plots).cols(6) lsp = hv.selection.link_selections.instance() self.linked_selection = lsp layout = self.linked_selection(layout) return layout
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
def make_gridplot(df_tidy, names, p1, p2, to_plot = 'concentration', logx = True, yrange = bokeh.models.Range1d(0, 15)): plots = [] for name in names: df_small = df_tidy.loc[df_tidy['species'] == name, :] points = hv.Points( data=df_small, kdims=[p1, to_plot], vdims=[p2], ) if logx: points.opts(color = p2, cmap = 'Blues', logx=True, title = name, colorbar = True, size= 7, frame_height=200, frame_width=200 * 3 // 2,) else: points.opts(color = p2, cmap = 'Blues', title = name, colorbar = True, size= 7, frame_height=200, frame_width=200 * 3 // 2,) # curve = hv.Curve(data = df_small, kdims=[p1, "concentration"], # vdims=[p2]).opts(logx=True,frame_height=200, frame_width=200 * 3 // 2) # overlay = hv.Overlay([points, curve]) p = hv.render(points) if name == 'H': p.y_range = yrange plots.append(p) return bokeh.layouts.gridplot(plots, ncols = 2)
def hvplot_view(self): """A holoviews.Points plot of the selected transform.""" df = self.interface.gem.data[ self.data_var_cats["all_labels"]].to_dataframe().reset_index() gene_set = frozenset(self.interface.get_gene_index()) transform_state = frozenset(self.get_transform_kwargs().items()) hover = HoverTool(tooltips=[(name, "@" + f"{name}") for name in list(df.columns)]) transform = self.cached_transform(gene_set, transform_state) df["x"] = transform[:, 0] df["y"] = transform[:, 1] plot = hv.Points(df, kdims=["x", "y"]) hue = self.hue if self.hue else "#3288bd" return plot.opts(tools=[hover], color=hue, cmap="Set1", legend_position='bottom', xaxis=None, yaxis=None, padding=0.05, show_grid=True, bgcolor="lightgrey", width=500, height=500)
def interactive_plot(features, y, times, index=None, title='', alpha=0.8, xlabel='dimension 1', ylabel='dimension 2'): """Create interactive points plot, of the embedded features. """ df = pd.DataFrame(features, columns=['feature_1', 'feature_2']) df['times'] = times df['y'] = y markers, sizes = gen_markers(y) df['marker'] = markers df['size'] = sizes if index is None: df['index'] = np.arange(len(times)) else: df['index'] = index cmap = gen_cmap(y) points = hv.Points(df) points.opts(width=800, height=550, labelled=[]) tooltips = [('Label', '@y'), ('Time', '@times{f}'), ('Index', '@index')] hover = HoverTool(tooltips=tooltips) points.opts(tools=[hover, 'tap', 'box_select'], size='size', color='y', cmap=cmap, line_color='black', padding=0.1, marker='marker', alpha=alpha, show_grid=True, title=title, xlabel=xlabel, ylabel=ylabel, nonselection_alpha=0.2, nonselection_line_color='gray', legend_position='left', hooks=[set_active_tool]) return points
def interactive_cmap(features, y, times, c, title=''): """Create interactive points plot, of the embedded features. """ df = pd.DataFrame(features, columns=['feature_1', 'feature_2']) df['times'] = times df['y'] = y df['c'] = c markers, sizes = gen_markers(y) # df['marker'] = markers # df['size'] = sizes points = hv.Points(df) points.opts(width=800, height=550, labelled=[]) tooltips = [('Label', '@y'), ('Time', '@times{f}')] hover = HoverTool(tooltips=tooltips) points.opts(tools=[hover, 'tap', 'box_select'], size=8, color='c', cmap='Viridis', line_color='black', padding=0.1, alpha=0.8, show_grid=True, title=title, nonselection_alpha=0.2, nonselection_line_color='gray', legend_position='left', hooks=[set_active_tool], colorbar=True) return points
def hitlets_to_hv_points( hitlets, t_ref=None, ): """ Function which converts hitlets into hv.Points used in the different plots. Computes hitlet times as relative times with respect to the first hitlet if t_ref is not set. """ import holoviews as hv if not len(hitlets): raise ValueError('Expected at least a single hitlet.') if isinstance(hitlets, np.ndarray): hitlets = pd.DataFrame(hitlets) # Set relative times: if t_ref is None: t_ref = min(hitlets['time']) time = seconds_from(hitlets['time'], t_ref, unit_conversion=1) hitlets['time'] = time hitlets['endtime'] = strax.endtime(hitlets.to_records()) hitlet_points = hv.Points(hitlets) return hitlet_points
def _plot_nveto(self, pmts, pmt_size, pmt_distance): if isinstance(pmts, pd.DataFrame): pmts = pmts.to_records(index=False) hv = self.hv # Get hitlet_points data and extract PMT data pmt_data = self._create_nveto_pmts(pmts, pmt_size, pmt_distance) pmts = hv.Points(data=pd.DataFrame(pmt_data), kdims=[ hv.Dimension('pmt_x', label='x [cm]'), hv.Dimension('pmt_y', label='y [cm]') ], vdims=['time', 'size', 'area', 'channel']).opts( size='size', tools=[self._create_pmt_pattern_hover()], color='time', colorbar=True, cmap='viridis', clabel='Time [ns]', line_color='black', alpha=0.8, width=400, title='nVETO Top View') return pmts
def view(self, component='vv', mapTitle=None, ncols=1, **kwargs): ''' Setup and return plot ''' self.component = component self.setNoDataValue(None) self.plotOptions = self._plotOpts(component, **kwargs) self.imgOptions = self._imgOpts(component, **kwargs) # Default titles if mapTitle is None: mapTitle = component # Setup the image plot. img = self.xArray[self.name].sel(band=self.component, time=self.bounds['maxt']) imgPlot = img.hvplot.image(rasterize=True, aspect='equal', title=mapTitle).opts( active_tools=['point_draw'], **self.imgOptions) # Setup up the time series plot points = hv.Points(([self.xc], [self.yc]), ).opts(size=6, color='red') pointer = hv.streams.PointDraw(source=points, data=points.columns(), num_objects=1) # Create the dynamic map pointer_dmap = hv.DynamicMap( lambda data: self.extractData(data['x'][0], data['y'][0]), streams=[pointer]).opts(width=500) # Return the result for display return pn.panel((imgPlot * points + pointer_dmap).cols(ncols).opts(merge_tools=False))
def plot_dsmap(stdname, timerange): df_dsmap = get_datasets( e, stdname, server.get("cdm_data_type"), timerange[0], timerange[1], server.get("skip_datasets"), ) easting, northing = hv.util.transform.lon_lat_to_easting_northing( df_dsmap.longitude, df_dsmap.latitude, ) df_dsmap.loc[:, "easting"] = easting df_dsmap["northing"] = northing dsmap = hv.Points(df_dsmap, kdims=["easting", "northing"]).opts( size=5, color="black", tools=["tap", hover1], alpha=0.4, ) return dsmap
def _records_to_points(*, records, to_pe, t_reference, config, unit_conversion=int(1e9)): """Return (holoviews.Points, time_stream) corresponding to records. """ import holoviews as hv areas_r = records['area'] * to_pe[records['channel']] # Create dataframe with record metadata df = pd.DataFrame( dict(area=areas_r, time=seconds_from(records['time'] + records['dt'] * records['length'] // 2, t_reference, unit_conversion=unit_conversion), length=records['length'], dt=records['dt'], channel=records['channel'])) rec_points = hv.Points(df, kdims=[ hv.Dimension('time', label='Time [µs]'), hv.Dimension('channel', label='PMT Channel', range=(0, config['n_tpc_pmts'])) ], vdims=[hv.Dimension('area', label='Area [pe]')]) time_stream = hv.streams.RangeX(source=rec_points) return rec_points, time_stream
def test_pnwidget_hvplot_links(document, comm): size_widget = FloatSlider(value=5, start=1, end=10) points1 = hv.Points([1, 2, 3]) size_widget.jslink(points1, value='glyph.size') row = Row(points1, size_widget) model = row._get_root(document, comm=comm) hv_views = row.select(HoloViews) widg_views = row.select(FloatSlider) assert len(hv_views) == 1 assert len(widg_views) == 1 slider = widg_views[0]._models[model.ref['id']] scatter = hv_views[0]._plots[model.ref['id']].handles['glyph'] link_customjs = slider.js_property_callbacks['change:value'][-1] assert link_customjs.args['source'] is slider assert link_customjs.args['target'] is scatter code = ( "value = source['value'];" "try { property = target.properties['size'];" "if (property !== undefined) { property.validate(value); } }" "catch(err) { console.log('WARNING: Could not set size on target, raised error: ' + err); return; }" "target['size'] = value") assert link_customjs.code == code
def test_bkwidget_hvplot_links(document, comm): from bokeh.models import Slider bokeh_widget = Slider(value=5, start=1, end=10, step=1e-1) points1 = hv.Points([1, 2, 3]) GenericLink(bokeh_widget, points1, properties={'value': 'glyph.size'}) row = Row(points1, bokeh_widget) model = row._get_root(document, comm=comm) hv_views = row.select(HoloViews) assert len(hv_views) == 1 slider = bokeh_widget scatter = hv_views[0]._plots[model.ref['id']].handles['glyph'] link_customjs = slider.js_property_callbacks['change:value'][-1] assert link_customjs.args['source'] is slider assert link_customjs.args['target'] is scatter code = ( "value = source['value'];" "try { property = target.properties['size'];" "if (property !== undefined) { property.validate(value); } }" "catch(err) { console.log('WARNING: Could not set size on target, raised error: ' + err); return; }" "target['size'] = value") assert link_customjs.code == code
def _records_to_points(*, records, to_pe, t_reference): """Return (holoviews.Points, time_stream) corresponding to records """ import holoviews as hv areas_r = records['area'] * to_pe[records['channel']] # Create dataframe with record metadata df = pd.DataFrame( dict(area=areas_r, time=seconds_from( records['time'] + records['dt'] * records['length'] // 2, t_reference), channel=records['channel'])) rec_points = hv.Points( df, kdims=[ hv.Dimension('time', label='Time', unit='sec'), hv.Dimension('channel', label='PMT number', range=(0, straxen.n_tpc_pmts)) ], vdims=[hv.Dimension('area', label='Area', unit='pe')]) time_stream = hv.streams.RangeX(source=rec_points) return rec_points, time_stream
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 plot_linear_pos(self, time, x_range=None, y_range=None, plt_range=10): linflat_sel_data = self.linflat['linpos_flat'].values linflat_sel_time = self.linflat.index.get_level_values('time') pos = hv.Points((linflat_sel_time, linflat_sel_data), kdims=[self.time_dim_name, self.pos_dim_name], extents=(time, None, time + plt_range, None), label=('linpos', 'Linear Position')) return pos
def modify_doc(doc): points = hv.Points(np.random.randn(100, 2)) points2 = hv.Points(np.random.randn(100, 2) * 2 + 1) xdist, ydist = ((hv.Distribution(points2, kdims=[dim]) * hv.Distribution(points, kdims=[dim])).redim.range(x=(-5, 5), y=(-5, 5)) for dim in 'xy') composition = (points2 * points) << ydist.opts(width=125) << xdist.opts(height=125) final = composition plot = renderer.get_plot(final) layout = row(plot.state) # renderer.server_doc(layout) doc.add_root(layout)
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 __size_legend(size_min, size_max, dot_min, dot_max, size_tick_labels_format, size_ticks): size_ticks_pixels = np.interp(size_ticks, (size_min, size_max), (dot_min, dot_max)) size_tick_labels = [size_tick_labels_format.format(x) for x in size_ticks] points = hv.Points( { 'x': np.repeat(0.15, len(size_ticks)), 'y': np.arange(len(size_ticks), 0, -1), 'size': size_ticks_pixels }, vdims='size').opts(xaxis=None, color='black', yaxis=None, size=dim('size')) labels = hv.Labels( { 'x': np.repeat(0.3, len(size_ticks)), 'y': np.arange(len(size_ticks), 0, -1), 'text': size_tick_labels }, ['x', 'y'], 'text').opts(text_align='left', text_font_size='9pt') overlay = (points * labels) overlay.opts(width=dot_max + 100, height=int(len(size_ticks) * (dot_max + 12)), xlim=(0, 1), ylim=(0, len(size_ticks) + 1), invert_yaxis=True, shared_axes=False, show_frame=False) return overlay