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
