def _stats_plot(self, element, y, data=None):
"""
Helper method to generate element from indexed dataframe.
"""
data, x, y = self._process_args(data, None, y)
opts = {
'plot': dict(self._plot_opts), # labelled=[]),
'norm': self._norm_opts,
'style': self._style_opts
}
if not isinstance(y, (list, tuple)):
ranges = {y: self._dim_ranges['y']}
return (element(
data, self.by,
y).redim.range(**ranges).relabel(**self._relabel).opts(**opts))
labelled = ['y' if self.invert else 'x'
] if self.group_label != 'Group' else []
if self.value_label != 'value':
labelled.append('x' if self.invert else 'y')
opts['plot']['labelled'] = labelled
kdims = [self.group_label]
ranges = {self.value_label: self._dim_ranges['y']}
data = data[list(y)]
if check_library(data, 'dask'):
from dask.dataframe import melt
else:
melt = pd.melt
df = melt(data, var_name=self.group_label, value_name=self.value_label)
return (element(
df, kdims, self.value_label).redim.range(**ranges).redim(
**self._redim).relabel(**self._relabel).opts(**opts))
def _category_plot(self, element, x, y, data):
"""
Helper method to generate element from indexed dataframe.
"""
labelled = ['y' if self.invert else 'x'] if x != 'index' else []
if self.value_label != 'value':
labelled.append('x' if self.invert else 'y')
opts = {
'plot': dict(self._plot_opts, labelled=labelled),
'style': dict(self._style_opts),
'norm': self._norm_opts
}
ranges = {self.value_label: self._dim_ranges['y']}
id_vars = [x]
if any((v in [data.index.names] + ['index']) or v == data.index.name
for v in id_vars):
data = data.reset_index()
data = data[y + [x]]
if check_library(data, 'dask'):
from dask.dataframe import melt
else:
melt = pd.melt
df = melt(data,
id_vars=[x],
var_name=self.group_label,
value_name=self.value_label)
kdims = [x, self.group_label]
return (element(
df, kdims, self.value_label).redim.range(**ranges).redim(
**self._redim).relabel(**self._relabel).opts(**opts))
def chart(self, element, x, y, data=None):
"Helper method for simple x vs. y charts"
data, x, y = self._process_args(data, x, y)
if x and y and not isinstance(y, (list, tuple)):
return self.single_chart(element, x, y, data)
elif x and y and len(y) == 1:
return self.single_chart(element, x, y[0], data)
labelled = ['y' if self.invert else 'x'] if x != 'index' else []
if self.value_label != 'value':
labelled.append('x' if self.invert else 'y')
opts = dict(plot=dict(self._plot_opts, labelled=labelled),
norm=self._norm_opts,
style=self._style_opts)
charts = []
for c in y:
chart = element(data, x, c).redim(**{c: self.value_label})
ranges = {
x: self._dim_ranges['x'],
self.value_label: self._dim_ranges['y']
}
charts.append((c, chart.relabel(**self._relabel).redim.range(
**ranges).opts(**opts)))
return self._by_type(charts, self.group_label,
sort=False).options('NdOverlay', batched=False)
def single_chart(self, element, x, y, data=None):
labelled = ['y' if self.invert else 'x'] if x != 'index' else []
if not self.is_series:
labelled.append('x' if self.invert else 'y')
elif not self.label:
self._relabel['label'] = y
opts = {
element.__name__:
dict(plot=dict(self._plot_opts, labelled=labelled),
norm=self._norm_opts,
style=self._style_opts)
}
ranges = {y: self._dim_ranges['y']}
if x:
ranges[x] = self._dim_ranges['x']
data = self.data if data is None else data
ys = [y]
for p in 'cs':
if p in self.kwds and self.kwds[p] in data.columns:
ys += [self.kwds[p]]
if self.by:
chart = Dataset(data, self.by + [x],
ys).to(element, x, ys,
self.by).relabel(**self._relabel)
chart = chart.layout() if self.subplots else chart.overlay(
).options(batched=False)
else:
chart = element(data, x, ys).relabel(**self._relabel)
return chart.redim.range(**ranges).redim(**self._redim).opts(opts)
def points(self, x=None, y=None, data=None):
data = self.data if data is None else data
params = dict(self._relabel)
plot_opts = dict(self._plot_opts)
if 'c' in self.kwds:
plot_opts['color_index'] = self.kwds['c']
if 's' in self.kwds:
plot_opts['size_index'] = self.kwds['s']
if 'marker' in self.kwds:
plot_opts['marker'] = self.kwds['marker']
opts = dict(plot=plot_opts,
style=self._style_opts,
norm=self._norm_opts)
element = Points
if self.crs is not None:
from geoviews import Points as element
params['crs'] = self.crs
vdims = [self.kwds['c']] if 'c' in self.kwds else []
if 's' in self.kwds:
vdims.append(self.kwds['s'])
return element(data, [x, y],
**params).redim(**self._redim).opts(**opts)
def quadmesh(self, x=None, y=None, z=None, data=None):
import xarray as xr
data = self.data if data is None else data
z = z or self.kwds.get('z')
x = x or self.x
y = y or self.y
if not (x and y):
x, y = list([k for k, v in data.coords.items() if v.size > 1])
if not z:
z = list(data.data_vars)[0] if isinstance(
data, xr.Dataset) else [data.name]
params = dict(self._relabel)
opts = dict(plot=self._plot_opts,
style=self._style_opts,
norm=self._norm_opts)
element = QuadMesh
if self.crs is not None:
from geoviews import QuadMesh as element
params['crs'] = self.crs
return element(data, [x, y], z,
**params).redim(**self._redim).opts(**opts)
def image(self, x=None, y=None, z=None, data=None):
import xarray as xr
data = self.data if data is None else data
z = z or self.kwds.get('z')
x = x or self.x
y = y or self.y
if not (x and y):
x, y = list(data.dims)[::-1]
if not z:
z = list(data.data_vars)[0] if isinstance(
data, xr.Dataset) else [data.name]
params = dict(self._relabel)
opts = dict(plot=self._plot_opts,
style=self._style_opts,
norm=self._norm_opts)
element = Image
if self.crs is not None:
from geoviews import Image as element
params['crs'] = self.crs
return element(data, [x, y], z,
**params).redim(**self._redim).opts(**opts)