class _Element(Element2D):
"""
Baseclass for Element2D types with associated cartopy
coordinate reference system.
"""
_abstract = True
crs = param.ClassSelector(default=ccrs.PlateCarree(),
class_=ccrs.CRS,
doc="""
Cartopy coordinate-reference-system specifying the
coordinate system of the data. Inferred automatically
when _Element wraps cartopy Feature object.""")
kdims = param.List(default=[Dimension('Longitude'),
Dimension('Latitude')],
bounds=(2, 2),
constant=True)
def __init__(self, data, kdims=None, vdims=None, **kwargs):
crs = None
if isinstance(data, HvDataset):
crs_data = data.data
else:
crs_data = data
if Cube and isinstance(crs_data, Cube):
coord_sys = crs_data.coord_system()
if hasattr(coord_sys, 'as_cartopy_projection'):
crs = coord_sys.as_cartopy_projection()
elif isinstance(crs_data, (cFeature, GoogleTiles)):
crs = crs_data.crs
supplied_crs = kwargs.get('crs', None)
if supplied_crs and crs and crs != supplied_crs:
raise ValueError('Supplied coordinate reference '
'system must match crs of the data.')
elif crs:
kwargs['crs'] = crs
elif isinstance(data, _Element):
kwargs['crs'] = data.crs
super(_Element, self).__init__(data,
kdims=kdims,
vdims=vdims,
**kwargs)
def clone(self,
data=None,
shared_data=True,
new_type=None,
*args,
**overrides):
if 'crs' not in overrides and (not new_type
or isinstance(new_type, _Element)):
overrides['crs'] = self.crs
return super(_Element, self).clone(data, shared_data, new_type, *args,
**overrides)
class Dataset(_Element, HvDataset):
"""
Coordinate system aware version of a HoloViews dataset.
"""
kdims = param.List(default=[Dimension('Longitude'),
Dimension('Latitude')],
constant=True)
group = param.String(default='Dataset')
def test_hex_tiles_count_aggregation(self):
tiles = HexTiles([(0, 0), (0.5, 0.5), (-0.5, -0.5), (-0.4, -0.4)])
binned = hex_binning(tiles, gridsize=3)
expected = HexTiles([(0, 0, 1), (2, -1, 1), (-2, 1, 2)],
kdims=[
Dimension('x', range=(-0.5, 0.5)),
Dimension('y', range=(-0.5, 0.5))
],
vdims='Count')
self.assertEqual(binned, expected)
class VectorField(_Element, HvVectorField):
"""
A VectorField contains is a collection of vectors where each
vector has an associated position. The vectors should be specified
by defining an angle in radians and a magnitude.
"""
group = param.String(default='VectorField', constant=True)
vdims = param.List(default=[Dimension('Angle', cyclic=True, range=(0,2*np.pi)),
Dimension('Magnitude')], bounds=(1, None))
def test_bokeh_server_dynamic_range_not_editable(self):
dim = Dimension('x', range=(3.1, 11.2))
widget, label, mapping = BokehServerWidgets.create_widget(dim, editable=False)
self.assertIsInstance(widget, Slider)
self.assertEqual(widget.value, 3.1)
self.assertEqual(widget.start, 3.1)
self.assertEqual(widget.end, 11.2)
self.assertEqual(widget.step, 0.01)
self.assertIsInstance(label, Div)
self.assertEqual(label.text, '<b>%s</b>' % dim.pprint_value_string(3.1))
self.assertIs(mapping, None)
def test_dynamic_values_partial_overlap(self):
kdims = [
Dimension('File', range=(0.01, 1)),
Dimension('SliceDimension', values=['x', 'y', 'z']),
Dimension('Coordinates', range=(0.01, 1))
]
dmap1 = DynamicMap(lambda x, y, z: Image(np.random.rand(10, 10)),
kdims=kdims)
dmap2 = DynamicMap(lambda x: Curve(np.random.rand(10, 2)) * VLine(x),
kdims=kdims[:1])
mpl_renderer.get_widget(dmap1 + dmap2, 'selection')
class Image(_Element, Dataset):
"""
Image represents a 2D array of some quantity with
some associated coordinates.
"""
kdims = param.List(default=[Dimension('x'), Dimension('y')])
vdims = param.List(default=[Dimension('z')], bounds=(1, 1))
group = param.String(default='Image')
def test_bokeh_server_dynamic_range_not_editable(self):
dim = Dimension('x', range=(3.1, 11.2))
widget, label, mapping = BokehServerWidgets.create_widget(dim, editable=False)
self.assertIsInstance(widget, Slider)
self.assertEqual(widget.value, 3.1)
self.assertEqual(widget.start, 3.1)
self.assertEqual(widget.end, 11.2)
self.assertEqual(widget.step, 0.01)
self.assertIsInstance(label, Div)
self.assertEqual(label.text, '<b>%s</b>' % dim.pprint_value_string(3.1))
self.assertIs(mapping, None)
class Nodes(_Element, HvNodes):
"""
Nodes is a simple Element representing Graph nodes as a set of
Points. Unlike regular Points, Nodes must define a third key
dimension corresponding to the node index.
"""
group = param.String(default='Nodes', constant=True)
kdims = param.List(default=[Dimension('Longitude'), Dimension('Latitude'),
Dimension('index')], bounds=(3, 3))
class Contours(_Element, Dataset):
"""
Contours represents a 2D array of some quantity with
some associated coordinates, which may be discretized
into one or more contours.
"""
kdims = param.List(default=[Dimension('x'), Dimension('y')])
vdims = param.List(default=[Dimension('z')], bounds=(1, 1))
group = param.String(default='Contours')
def test_hex_tiles_sum_value_aggregation(self):
tiles = HexTiles([(0, 0, 1), (0.5, 0.5, 2), (-0.5, -0.5, 3),
(-0.4, -0.4, 4)],
vdims='z')
binned = hex_binning(tiles, gridsize=3, aggregator=np.sum)
expected = HexTiles([(0, 0, 1), (2, -1, 2), (-2, 1, 7)],
kdims=[
Dimension('x', range=(-0.5, 0.5)),
Dimension('y', range=(-0.5, 0.5))
],
vdims='z')
self.assertEqual(binned, expected)
def test_bokeh_server_dynamic_values_float_not_editable(self):
values = list(np.linspace(3.1, 11.2, 7))
dim = Dimension('x', values=values)
widget, label, mapping = BokehServerWidgets.create_widget(dim, editable=False)
self.assertIsInstance(widget, Slider)
self.assertEqual(widget.value, 0)
self.assertEqual(widget.start, 0)
self.assertEqual(widget.end, 6)
self.assertEqual(widget.step, 1)
self.assertIsInstance(label, Div)
self.assertEqual(label.text, '<b>%s</b>' % dim.pprint_value_string(3.1))
self.assertEqual(mapping, [(i, (v, dim.pprint_value(v))) for i, v in enumerate(values)])
def test_bokeh_server_dynamic_values_float_not_editable(self):
values = list(np.linspace(3.1, 11.2, 7))
dim = Dimension('x', values=values)
widget, label, mapping = BokehServerWidgets.create_widget(dim, editable=False)
self.assertIsInstance(widget, Slider)
self.assertEqual(widget.value, 0)
self.assertEqual(widget.start, 0)
self.assertEqual(widget.end, 6)
self.assertEqual(widget.step, 1)
self.assertIsInstance(label, Div)
self.assertEqual(label.text, '<b>%s</b>' % dim.pprint_value_string(3.1))
self.assertEqual(mapping, [(i, (v, dim.pprint_value(v))) for i, v in enumerate(values)])
def test_bokeh_server_dynamic_values_float_editable(self):
values = list(np.linspace(3.1, 11.2, 7))
dim = Dimension('x', values=values)
widget, label, mapping = BokehServerWidgets.create_widget(dim, editable=True)
self.assertIsInstance(widget, Slider)
self.assertEqual(widget.value, 0)
self.assertEqual(widget.start, 0)
self.assertEqual(widget.end, 6)
self.assertEqual(widget.step, 1)
self.assertIsInstance(label, AutocompleteInput)
self.assertEqual(label.title, dim.pprint_label)
self.assertEqual(label.value, '3.1')
self.assertEqual(mapping, [(v, dim.pprint_value(v)) for v in values])
def test_bokeh_server_dynamic_values_float_editable(self):
values = list(np.linspace(3.1, 11.2, 7))
dim = Dimension('x', values=values)
widget, label, mapping = BokehServerWidgets.create_widget(dim, editable=True)
self.assertIsInstance(widget, Slider)
self.assertEqual(widget.value, 0)
self.assertEqual(widget.start, 0)
self.assertEqual(widget.end, 6)
self.assertEqual(widget.step, 1)
self.assertIsInstance(label, AutocompleteInput)
self.assertEqual(label.title, dim.pprint_label)
self.assertEqual(label.value, '3.1')
self.assertEqual(mapping, [(v, dim.pprint_value(v)) for v in values])
def test_bokeh_server_dynamic_values_int(self):
values = list(range(3, 11))
dim = Dimension('x', values=values)
widget, label, mapping = BokehServerWidgets.create_widget(dim, editable=True)
self.assertIsInstance(widget, Slider)
self.assertEqual(widget.value, 0)
self.assertEqual(widget.start, 0)
self.assertEqual(widget.end, 7)
self.assertEqual(widget.step, 1)
self.assertIsInstance(label, AutocompleteInput)
self.assertEqual(label.title, dim.pprint_label)
self.assertEqual(label.value, '3')
self.assertEqual(mapping, [(i, (v, dim.pprint_value(v))) for i, v in enumerate(values)])
def test_bokeh_server_static_numeric_values(self):
dim = Dimension('x')
ndmap = NdMapping({i: None for i in range(3, 12)}, kdims=['x'])
widget, label, mapping = BokehServerWidgets.create_widget(dim, ndmap, editable=True)
self.assertIsInstance(widget, Slider)
self.assertEqual(widget.value, 0)
self.assertEqual(widget.start, 0)
self.assertEqual(widget.end, 8)
self.assertEqual(widget.step, 1)
self.assertIsInstance(label, AutocompleteInput)
self.assertEqual(label.title, dim.pprint_label)
self.assertEqual(label.value, '3')
self.assertEqual(mapping, [(i, (k, dim.pprint_value(k))) for i, k in enumerate(ndmap.keys())])
def test_bokeh_server_static_numeric_values(self):
dim = Dimension('x')
ndmap = NdMapping({i: None for i in range(3, 12)}, kdims=['x'])
widget, label, mapping = BokehServerWidgets.create_widget(dim, ndmap, editable=True)
self.assertIsInstance(widget, Slider)
self.assertEqual(widget.value, 0)
self.assertEqual(widget.start, 0)
self.assertEqual(widget.end, 8)
self.assertEqual(widget.step, 1)
self.assertIsInstance(label, AutocompleteInput)
self.assertEqual(label.title, dim.pprint_label)
self.assertEqual(label.value, '3')
self.assertEqual(mapping, [(i, (k, dim.pprint_value(k))) for i, k in enumerate(ndmap.keys())])
def test_bokeh_server_dynamic_values_int(self):
values = list(range(3, 11))
dim = Dimension('x', values=values)
widget, label, mapping = BokehServerWidgets.create_widget(dim, editable=True)
self.assertIsInstance(widget, Slider)
self.assertEqual(widget.value, 0)
self.assertEqual(widget.start, 0)
self.assertEqual(widget.end, 7)
self.assertEqual(widget.step, 1)
self.assertIsInstance(label, AutocompleteInput)
self.assertEqual(label.title, dim.pprint_label)
self.assertEqual(label.value, '3')
self.assertEqual(mapping, [(i, (v, dim.pprint_value(v))) for i, v in enumerate(values)])
def setUp(self):
super(DimensionsComparisonTestCase, self).setUp()
self.dimension1 = Dimension('dim1', range=(0, 1))
self.dimension2 = Dimension('dim2', range=(0, 1))
self.dimension3 = Dimension('dim1', range=(0, 2))
self.dimension4 = Dimension('dim1')
self.dimension5 = Dimension('dim1', cyclic=True)
self.dimension6 = Dimension('dim1', cyclic=True, range=(0, 1))
self.dimension7 = Dimension('dim1',
cyclic=True,
range=(0, 1),
unit='ms')
self.dimension8 = Dimension('dim1', values=['a', 'b'])
self.dimension9 = Dimension('dim1', type=int)
self.dimension10 = Dimension('dim1', type=float)
def test_holomap_slider_and_dropdown(self):
hmap = HoloMap({(i, chr(65 + i)): Curve([1, 2, 3])
for i in range(10)}, ['X', 'Y'])
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(len(widgets), 2)
slider = widgets[0]
self.assertEqual(slider['type'], 'slider')
self.assertEqual(slider['dim'], 'X')
self.assertEqual(slider['dim_idx'], 0)
self.assertEqual(slider['vals'],
repr([repr(float(v)) for v in range(10)]))
self.assertEqual(slider['labels'], repr([str(v) for v in range(10)]))
self.assertEqual(slider['step'], 1)
self.assertEqual(slider['default'], 0)
self.assertEqual(slider['next_dim'], Dimension('Y'))
self.assertEqual(eval(slider['next_vals']),
{str(float(i)): [chr(65 + i)]
for i in range(10)})
dropdown = widgets[1]
self.assertEqual(dropdown['type'], 'dropdown')
self.assertEqual(dropdown['dim'], 'Y')
self.assertEqual(dropdown['dim_idx'], 1)
self.assertEqual(dropdown['vals'],
repr([chr(65 + v) for v in range(10)]))
self.assertEqual(dropdown['labels'],
repr([chr(65 + v) for v in range(10)]))
self.assertEqual(dropdown['step'], 1)
self.assertEqual(dropdown['default'], 0)
self.assertIs(dropdown['next_dim'], None)
self.assertEqual(dimensions, ['X', 'Y'])
self.assertEqual(init_dim_vals, repr(['0.0', 'A']))
def test_dynamicmap_range_default(self):
dimension = Dimension('X', range=(0., 5.), default=0.05)
hmap = DynamicMap(lambda x: Curve([1, 2, 3]), kdims=[dimension])
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(widgets[0]['default'], 0.05)
self.assertEqual(init_dim_vals, '[0.050000000]')
class Image(_Element, HvImage):
"""
Image represents a 2D array of some quantity with
some associated coordinates.
"""
vdims = param.List(default=[Dimension('z')], bounds=(1, None))
group = param.String(default='Image')
@classmethod
def load_tiff(cls,
filename,
crs=None,
apply_transform=False,
nan_nodata=False,
**kwargs):
return load_tiff(filename, crs, apply_transform, **kwargs)
@classmethod
def from_xarray(cls,
da,
crs=None,
apply_transform=False,
nan_nodata=False,
**kwargs):
return from_xarray(da, crs, apply_transform, **kwargs)
def test_hex_tiles_hover_weighted(self):
tiles = HexTiles([(0, 0, 0.1), (0.5, 0.5, 0.2), (-0.5, -0.5, 0.3)],
vdims='z').options(aggregator=np.mean)
plot = list(bokeh_renderer.get_plot(tiles).subplots.values())[0]
dims, opts = plot._hover_opts(tiles)
self.assertEqual(dims, [Dimension('z')])
self.assertEqual(opts, {})
def test_dynamicmap_unsorted_numeric_values_slider_plot_update(self):
dims = [Dimension('N', values=[10, 5, 0])]
dmap = DynamicMap(lambda N: Curve([1, N, 5]), kdims=dims)
widgets = bokeh_renderer.get_widget(dmap, 'widgets')
widgets.get_widgets()
widgets.update((2,))
self.assertEqual(widgets.plot.current_key, (10,))
def test_holomap_dropdown_default(self):
dim = Dimension('X', default='C')
hmap = HoloMap({chr(65 + i): Curve([1, 2, 3]) for i in range(10)}, dim)
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(widgets[0]['default'], '2')
self.assertEqual(init_dim_vals, "['C']")
def test_hex_tiles_hover_count(self):
tiles = HexTiles([(0, 0), (0.5, 0.5), (-0.5, -0.5),
(-0.4, -0.4)]).options(tools=['hover'])
plot = list(bokeh_renderer.get_plot(tiles).subplots.values())[0]
dims, opts = plot._hover_opts(tiles)
self.assertEqual(dims, [Dimension('Count')])
self.assertEqual(opts, {})
def test_holomap_slider_default(self):
dim = Dimension('X', default=3)
hmap = HoloMap({i: Curve([1, 2, 3]) for i in range(1, 9)}, dim)
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(widgets[0]['default'], '2')
self.assertEqual(init_dim_vals, "['3.0']")
class QuadMesh(_Element, HvQuadMesh):
"""
QuadMesh is a Raster type to hold x- and y- bin values
with associated values. The x- and y-values of the QuadMesh
may be supplied either as the edges of each bin allowing
uneven sampling or as the bin centers, which will be converted
to evenly sampled edges.
As a secondary but less supported mode QuadMesh can contain
a mesh of quadrilateral coordinates that is not laid out in
a grid. The data should then be supplied as three separate
2D arrays for the x-/y-coordinates and grid values.
"""
datatype = param.List(default=['grid', 'xarray'])
vdims = param.List(default=[Dimension('z')], bounds=(1, 1))
group = param.String(default='QuadMesh')
_binned = True
def trimesh(self):
trimesh = super(QuadMesh, self).trimesh()
node_params = get_param_values(trimesh.nodes)
nodes = TriMesh.node_type(trimesh.nodes.data, **node_params)
return TriMesh((trimesh.data, nodes),
crs=self.crs,
**get_param_values(trimesh))
def test_element_formatter_xaxis(self):
def formatter(x):
return '%s' % x
curve = Curve(range(10),
kdims=[Dimension('x', value_format=formatter)])
plot = bokeh_renderer.get_plot(curve).state
self.assertIsInstance(plot.xaxis[0].formatter, FuncTickFormatter)
def test_dimension_call(self):
dim1 = Dimension('Test dimension')
dim2 = dim1(cyclic=True)
self.assertEqual(dim2.cyclic,True)
dim3 = dim1('New test dimension', unit='scovilles')
self.assertEqual(dim3.name, 'New test dimension')
self.assertEqual(dim3.unit, 'scovilles')
def test_dynamicmap_values_default(self):
values = [chr(65 + i) for i in range(10)]
dimension = Dimension('X', values=values, default='C')
hmap = DynamicMap(lambda x: Curve([1, 2, 3]), kdims=[dimension])
widgets = bokeh_renderer.get_widget(hmap, 'widgets')
widgets, dimensions, init_dim_vals = widgets.get_widgets()
self.assertEqual(widgets[0]['default'], '2')
self.assertEqual(init_dim_vals, repr(['2']))
def __init__(self, data, kdims=None, vdims=None, **params):
if params.get('level') is not None:
if vdims is None:
vdims = [Dimension('Level')]
self.warning('Supplying a level to a Shape is deprecated '
'provide the value as part of a dictionary of '
'the form {\'geometry\': <shapely.Geometry>, '
'\'level\': %s} instead' % params['level'])
super(Shape, self).__init__(data, kdims=kdims, vdims=vdims, **params)
def setUp(self):
super(RasterMapTestCase, self).setUp()
# Example 1D map
self.map1_1D = HoloMap(key_dimensions=['int'])
self.map1_1D[0] = self.mat1
self.map1_1D[1] = self.mat2
# Changed keys...
self.map2_1D = HoloMap(key_dimensions=['int'])
self.map2_1D[1] = self.mat1
self.map2_1D[2] = self.mat2
# Changed number of keys...
self.map3_1D = HoloMap(key_dimensions=['int'])
self.map3_1D[1] = self.mat1
self.map3_1D[2] = self.mat2
self.map3_1D[3] = self.mat3
# Changed values...
self.map4_1D = HoloMap(key_dimensions=['int'])
self.map4_1D[0] = self.mat1
self.map4_1D[1] = self.mat3
# Changed bounds...
self.map5_1D = HoloMap(key_dimensions=['int'])
self.map5_1D[0] = self.mat4
self.map5_1D[1] = self.mat5
# Example dimension label
self.map6_1D = HoloMap(key_dimensions=['int_v2'])
self.map6_1D[0] = self.mat1
self.map6_1D[1] = self.mat2
# A HoloMap of Overlays
self.map7_1D = HoloMap(key_dimensions=['int'])
self.map7_1D[0] = self.overlay1_depth2
self.map7_1D[1] = self.overlay2_depth2
# A different HoloMap of Overlays
self.map8_1D = HoloMap(key_dimensions=['int'])
self.map8_1D[0] = self.overlay2_depth2
self.map8_1D[1] = self.overlay1_depth2
# Example 2D map
self.map1_2D = HoloMap(key_dimensions=['int', Dimension('float')])
self.map1_2D[0, 0.5] = self.mat1
self.map1_2D[1, 1.0] = self.mat2
# Changed 2D keys...
self.map2_2D = HoloMap(key_dimensions=['int', Dimension('float')])
self.map2_2D[0, 1.0] = self.mat1
self.map2_2D[1, 1.5] = self.mat2
def widgets_from_dimensions(cls, object, widget_types={}, widgets_type='individual'):
from holoviews.core import Dimension
from holoviews.core.util import isnumeric, unicode
from holoviews.core.traversal import unique_dimkeys
from .widgets import Widget, DiscreteSlider, Select, FloatSlider
dims, keys = unique_dimkeys(object)
if dims == [Dimension('Frame')] and keys == [(0,)]:
return [], {}
nframes = 1
values = dict(zip(dims, zip(*keys)))
dim_values = OrderedDict()
widgets = []
for dim in dims:
widget_type, widget = None, None
vals = dim.values or values.get(dim, None)
dim_values[dim.name] = vals
if widgets_type == 'scrubber':
if not vals:
raise ValueError('Scrubber widget may only be used if all dimensions define values.')
nframes *= len(vals)
elif dim.name in widget_types:
widget = widget_types[dim.name]
if isinstance(widget, Widget):
widgets.append(widget)
continue
elif isinstance(widget, type) and issubclass(widget, Widget):
widget_type = widget
else:
raise ValueError('Explicit widget definitions expected '
'to be a widget instance or type, %s '
'dimension widget declared as %s.' %
(dim, widget))
if vals:
if all(isnumeric(v) for v in vals):
vals = sorted(vals)
labels = [unicode(dim.pprint_value(v)) for v in vals]
options = OrderedDict(zip(labels, vals))
widget_type = widget_type or DiscreteSlider
else:
options = list(vals)
widget_type = widget_type or Select
default = vals[0] if dim.default is None else dim.default
widget = widget_type(name=dim.label, options=options, value=default)
elif dim.range != (None, None):
default = dim.range[0] if dim.default is None else dim.default
step = 0.1 if dim.step is None else dim.step
widget_type = widget_type or FloatSlider
widget = widget_type(step=step, name=dim.label, start=dim.range[0],
end=dim.range[1], value=default)
if widget is not None:
widgets.append(widget)
if widgets_type == 'scrubber':
widgets = [Player(length=nframes)]
return widgets, dim_values
def test_simple_values_clone(self):
dim = Dimension('test', values=[1,2,3])
self.assertEqual(dim.values, [1,2,3])
clone = dim.clone(values=[4,5,6])
self.assertEqual(clone.name, 'test')
self.assertEqual(clone.values, [4,5,6])
def test_tuple_clone(self):
dim = Dimension('test')
self.assertEqual(dim.name, 'test')
clone = dim.clone(('test', 'A test'))
self.assertEqual(clone.name, 'test')
self.assertEqual(clone.label, 'A test')
def test_simple_label_clone(self):
dim = Dimension('test')
self.assertEqual(dim.name, 'test')
clone = dim.clone(label='label')
self.assertEqual(clone.name, 'test')
self.assertEqual(clone.label, 'label')
def test_dimension_pprint(self):
dim = Dimension('Test dimension', cyclic=True, type=float, unit='Twilight zones')
self.assertEqual(dim.pprint_value_string(3.2345), 'Test dimension: 3.23 Twilight zones')
self.assertEqual(dim.pprint_value_string(4.2344), 'Test dimension: 4.23 Twilight zones')
def test_simple_clone(self):
dim = Dimension('test')
self.assertEqual(dim.name, 'test')
self.assertEqual(dim.clone('bar').name, 'bar')
