def test_unique_keys_no_overlap_exception(self):
hmap1 = HoloMap({i: Curve(range(10)) for i in range(5)}, kdims=['A'])
hmap2 = HoloMap({i: Curve(range(10)) for i in range(3, 10)})
exception = ('When combining HoloMaps into a composite plot '
'their dimensions must be subsets of each other.')
with self.assertRaisesRegexp(Exception, exception):
dims, keys = unique_dimkeys(hmap1 + hmap2)
def test_layout_overlay_holomap(self):
t = (self.el1 + self.el2) * HoloMap({0: self.el3})
self.assertEqual(
t,
Layout([
HoloMap({0: self.el1 * self.el3}),
HoloMap({0: self.el2 * self.el3})
]))
def test_layout_title(self):
hmap1 = HoloMap({a: Image(np.random.rand(10, 10)) for a in range(3)})
hmap2 = HoloMap({a: Image(np.random.rand(10, 10)) for a in range(3)})
plot = bokeh_renderer.get_plot(hmap1 + hmap2)
title = plot.handles['title']
self.assertIsInstance(title, Div)
text = "<span style='font-size: 16pt'><b>Default: 0</b></font>"
self.assertEqual(title.text, text)
def test_layout_overlay_holomap_reverse(self):
t = HoloMap({0: self.el3}) * (self.el1 + self.el2)
self.assertEqual(
t,
Layout([
HoloMap({0: self.el3 * self.el1}),
HoloMap({0: self.el3 * self.el2})
]))
def test_layout_title_fontsize(self):
hmap1 = HoloMap({a: Image(np.random.rand(10, 10)) for a in range(3)})
hmap2 = HoloMap({a: Image(np.random.rand(10, 10)) for a in range(3)})
layout = Layout([hmap1, hmap2])(plot=dict(fontsize={'title': '12pt'}))
plot = bokeh_renderer.get_plot(layout)
title = plot.handles['title']
self.assertIsInstance(title, Div)
text = "<span style='font-size: 12pt'><b>Default: 0</b></font>"
self.assertEqual(title.text, text)
def _update_proj_cog(self, p, proj):
"""Measure the CoG of the specified projection and register corresponding SheetViews."""
sheet = proj.dest
rows, cols = sheet.activity.shape
xcog = np.zeros((rows, cols), np.float64)
ycog = np.zeros((rows, cols), np.float64)
for r in xrange(rows):
for c in xrange(cols):
cf = proj.cfs[r, c]
r1, r2, c1, c2 = cf.input_sheet_slice
row_centroid, col_centroid = centroid(cf.weights)
xcentroid, ycentroid = proj.src.matrix2sheet(
r1 + row_centroid + 0.5, c1 + col_centroid + 0.5)
xcog[r][c] = xcentroid
ycog[r][c] = ycentroid
metadata = AttrDict(precedence=sheet.precedence,
row_precedence=sheet.row_precedence,
src_name=sheet.name)
timestamp = topo.sim.time()
lbrt = sheet.bounds.lbrt()
xsv = Image(xcog,
sheet.bounds,
label=proj.name,
group='X CoG',
vdims=[Dimension('X CoG', range=(lbrt[0], lbrt[2]))])
ysv = Image(ycog,
sheet.bounds,
label=proj.name,
group='Y CoG',
vdims=[Dimension('Y CoG', range=(lbrt[1], lbrt[3]))])
lines = []
hlines, vlines = xsv.data.shape
for hind in range(hlines)[::p.stride]:
lines.append(np.vstack([xsv.data[hind, :].T, ysv.data[hind, :]]).T)
for vind in range(vlines)[::p.stride]:
lines.append(np.vstack([xsv.data[:, vind].T, ysv.data[:, vind]]).T)
cogmesh = Contours(lines,
extents=sheet.bounds.lbrt(),
label=proj.name,
group='Center of Gravity')
xcog_map = HoloMap((timestamp, xsv), kdims=[features.Time])
xcog_map.metadata = metadata
ycog_map = HoloMap((timestamp, ysv), kdims=[features.Time])
ycog_map.metadata = metadata
contour_map = HoloMap((timestamp, cogmesh), kdims=[features.Time])
contour_map.metadata = metadata
return {'XCoG': xcog_map, 'YCoG': ycog_map, 'CoG': contour_map}
def test_unique_keys_partial_overlap(self):
hmap1 = HoloMap(
{(i, j): Curve(range(10))
for i in range(5) for j in range(3)},
kdims=['A', 'B'])
hmap2 = HoloMap({i: Curve(range(10)) for i in range(5)}, kdims=['A'])
dims, keys = unique_dimkeys(hmap1 + hmap2)
self.assertEqual(hmap1.kdims, dims)
self.assertEqual(keys,
[(i, j) for i in range(5) for j in list(range(3))])
def setUp(self):
super(TestWidgets, self).setUp()
im1 = Image(np.array([[1, 2], [3, 4]]))
im2 = Image(np.array([[1, 2], [3, 5]]))
holomap = HoloMap(initial_items=[(0, im1), (1, im2)], kdims=['test'])
self.plot1 = RasterPlot(im1)
self.plot2 = RasterPlot(holomap)
def test_render_holomap_individual_widget_position(self):
hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)})
obj, _ = self.renderer.instance(widget_location='top')._validate(hmap, None)
self.assertIsInstance(obj, pn.pane.HoloViews)
self.assertEqual(obj.center, True)
self.assertEqual(obj.widget_location, 'top')
self.assertEqual(obj.widget_type, 'individual')
def setUp(self):
if 'bokeh' not in Store.renderers:
raise SkipTest("Bokeh required to test widgets")
self.image1 = Image(np.array([[0, 1], [2, 3]]), label='Image1')
self.image2 = Image(np.array([[1, 0], [4, -2]]), label='Image2')
self.map1 = HoloMap({1: self.image1, 2: self.image2}, label='TestMap')
self.renderer = BokehRenderer.instance()
def test_dynamic_holomap_overlay(self):
fn = lambda i: Image(sine_array(0, i))
dmap = DynamicMap(fn, sampled=True)
hmap = HoloMap({i: Image(sine_array(0, i * 2)) for i in range(10)})
dynamic_overlay = dmap * hmap
overlaid = Image(sine_array(0, 5)) * Image(sine_array(0, 10))
self.assertEqual(dynamic_overlay[5], overlaid)
def update_sheet_activity(sheet_name, force=False):
"""
Update the '_activity_buffer' ViewMap for a given sheet by name.
If force is False and the existing Activity Image isn't stale,
the existing view is returned.
"""
name = 'ActivityBuffer'
sheet = topo.sim.objects(Sheet)[sheet_name]
view = sheet.views.Maps.get(name, False)
time = topo.sim.time()
metadata = AttrDict(precedence=sheet.precedence,
row_precedence=sheet.row_precedence,
src_name=sheet.name,
shape=sheet.activity.shape,
timestamp=time)
if not view:
im = Image(np.array(sheet.activity), sheet.bounds)
im.metadata = metadata
view = HoloMap((time, im), key_dimensions=[Time])
view.metadata = metadata
sheet.views.Maps[name] = view
else:
if force or view.range('Time')[1] < time:
im = Image(np.array(sheet.activity), sheet.bounds)
im.metadata = metadata
view[time] = im
return view
def test_holomap_redim_nested(self):
hmap = HoloMap({i: Dataset({'x':self.xs, 'y': self.ys * i},
kdims=['x'], vdims=['y'])
for i in range(10)}, kdims=['z'])
redimmed = hmap.redim(x='Time', z='Magnitude')
self.assertEqual(redimmed.dimensions('all', True),
['Magnitude', 'Time', 'y'])
def test_holomap_hist_two_dims(self):
hmap = HoloMap({i: Dataset({'x':self.xs, 'y': self.ys * i},
kdims=['x'], vdims=['y'])
for i in range(10)}, kdims=['z'])
hists = hmap.hist(dimension=['x', 'y'])
self.assertEqual(hists['right'].last.kdims, ['y'])
self.assertEqual(hists['top'].last.kdims, ['x'])
def setUp(self):
self.basename = 'no-file'
self.image1 = Image(np.array([[0, 1], [2, 3]]), label='Image1')
self.image2 = Image(np.array([[1, 0], [4, -2]]), label='Image2')
self.map1 = HoloMap({1: self.image1, 2: self.image2}, label='TestMap')
self.renderer = Store.renderer.instance()
def test_dataset_groupby(self):
group1 = {'Age':[10,16], 'Weight':[15,18], 'Height':[0.8,0.6]}
group2 = {'Age':[12], 'Weight':[10], 'Height':[0.8]}
grouped = HoloMap([('M', Dataset(group1, kdims=['Age'], vdims=self.vdims)),
('F', Dataset(group2, kdims=['Age'], vdims=self.vdims))],
kdims=['Gender'])
self.assertEqual(self.table.groupby(['Gender']), grouped)
def test_render_holomap_scrubber_fps(self):
hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)})
obj, _ = self.renderer.instance(fps=2)._validate(hmap, 'scrubber')
self.assertIsInstance(obj, pn.pane.HoloViews)
widgets = obj.layout.select(Player)
self.assertEqual(len(widgets), 1)
player = widgets[0]
self.assertEqual(player.interval, 500)
def test_columns_groupby(self):
group1 = {'Age': [10, 16], 'Weight': [15, 18], 'Height': [0.8, 0.6]}
group2 = {'Age': [12], 'Weight': [10], 'Height': [0.8]}
with sorted_context(False):
grouped = HoloMap(
[('M', Columns(group1, kdims=['Age'], vdims=self.vdims)),
('F', Columns(group2, kdims=['Age'], vdims=self.vdims))],
kdims=['Gender'])
self.assertEqual(self.table.groupby(['Gender']), grouped)
def setUp(self):
self.data1 = 'An example of arbitrary data'
self.data2 = 'Another example...'
self.data3 = 'A third example.'
self.view1 = Element(self.data1, label='View1')
self.view2 = Element(self.data2, label='View2')
self.view3 = Element(self.data3, label='View3')
self.hmap = HoloMap({0: self.view1, 1: self.view2, 2: self.view3})
def test_dataset_groupby_alias(self):
group1 = {'age':[10,16], 'weight':[15,18], 'height':[0.8,0.6]}
group2 = {'age':[12], 'weight':[10], 'height':[0.8]}
grouped = HoloMap([('M', Dataset(group1, kdims=[('age', 'Age')],
vdims=self.alias_vdims)),
('F', Dataset(group2, kdims=[('age', 'Age')],
vdims=self.alias_vdims))],
kdims=[('gender', 'Gender')])
self.assertEqual(self.alias_table.groupby('Gender'), grouped)
def anim(self,
duration,
offset=0,
timestep=1,
label=None,
unit=None,
time_fn=param.Dynamic.time_fn):
"""
duration: The temporal duration to animate in the units
defined on the global time function.
offset: The temporal offset from which the animation is
generated given the supplied pattern
timestep: The time interval between successive frames. The
duration must be an exact multiple of the timestep.
label: A label string to override the label of the global time
function (if not None).
unit: The unit string to override the unit value of the global
time function (if not None).
time_fn: The global time function object that is shared across
the time-varying objects that are being sampled.
Note that the offset, timestep and time_fn only affect
patterns parameterized by time-dependent number
generators. Otherwise, the frames are generated by successive
call to the pattern which may or may not be varying (e.g to
view the patterns contained within a Selector).
"""
frames = (duration // timestep) + 1
if duration % timestep != 0:
raise ValueError(
"The duration value must be an exact multiple of the timestep."
)
if label is None:
label = time_fn.label if hasattr(time_fn, 'label') else 'Time'
unit = time_fn.unit if (not unit
and hasattr(time_fn, 'unit')) else unit
vmap = HoloMap(
key_dimensions=[Dimension(label, unit=unit if unit else '')])
self.state_push()
with time_fn as t:
t(offset)
for i in range(frames):
vmap[t()] = self[:]
t += timestep
self.state_pop()
return vmap
def test_render_holomap_individual(self):
hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)})
obj, _ = self.renderer._validate(hmap, None)
self.assertIsInstance(obj, pn.pane.HoloViews)
self.assertEqual(obj.center, True)
self.assertEqual(obj.widget_location, 'right')
self.assertEqual(obj.widget_type, 'individual')
widgets = obj.layout.select(DiscreteSlider)
self.assertEqual(len(widgets), 1)
slider = widgets[0]
self.assertEqual(slider.options, OrderedDict([(str(i), i) for i in range(5)]))
def test_overlay_update_sources(self):
hmap = HoloMap({
i: (Curve(np.arange(i), label='A') *
Curve(np.arange(i) * 2, label='B'))
for i in range(10, 13)
})
plot = bokeh_renderer.get_plot(hmap)
plot.update((12, ))
subplot1, subplot2 = plot.subplots.values()
self.assertEqual(subplot1.handles['source'].data['y'], np.arange(12))
self.assertEqual(subplot2.handles['source'].data['y'],
np.arange(12) * 2)
def test_render_holomap_scrubber(self):
hmap = HoloMap({i: Curve([1, 2, i]) for i in range(5)})
obj, _ = self.renderer._validate(hmap, 'scrubber')
self.assertIsInstance(obj, pn.pane.HoloViews)
self.assertEqual(obj.center, True)
self.assertEqual(obj.widget_location, 'bottom')
self.assertEqual(obj.widget_type, 'scrubber')
widgets = obj.layout.select(Player)
self.assertEqual(len(widgets), 1)
player = widgets[0]
self.assertEqual(player.start, 0)
self.assertEqual(player.end, 4)
def setUp(self):
if 'bokeh' not in Store.renderers and pn is not None:
raise SkipTest("Bokeh and Panel required to test 'bokeh' renderer")
self.image1 = Image(np.array([[0, 1], [2, 3]]), label='Image1')
self.image2 = Image(np.array([[1, 0], [4, -2]]), label='Image2')
self.map1 = HoloMap({1: self.image1, 2: self.image2}, label='TestMap')
self.renderer = BokehRenderer.instance()
self.nbcontext = Renderer.notebook_context
self.comm_manager = Renderer.comm_manager
with param.logging_level('ERROR'):
Renderer.notebook_context = False
Renderer.comm_manager = CommManager
def test_grid_title(self):
grid = GridSpace({
(i, j):
HoloMap({a: Image(np.random.rand(10, 10))
for a in range(3)},
kdims=['X'])
for i in range(2) for j in range(3)
})
plot = bokeh_renderer.get_plot(grid)
title = plot.handles['title']
self.assertIsInstance(title, Div)
text = "<span style='font-size: 16pt'><b>X: 0</b></font>"
self.assertEqual(title.text, text)
def test_holomap_map_with_none(self):
hmap = HoloMap(
{
i: Dataset(
{
'x': self.xs,
'y': self.ys * i
}, kdims=['x'], vdims=['y'])
for i in range(10)
},
kdims=['z'])
mapped = hmap.map(lambda x: x if x.range(1)[1] > 0 else None, Dataset)
self.assertEqual(hmap[1:10], mapped)
def setUp(self):
if 'matplotlib' not in Store.renderers:
raise SkipTest("Matplotlib required to test widgets")
self.basename = 'no-file'
self.image1 = Image(np.array([[0,1],[2,3]]), label='Image1')
self.image2 = Image(np.array([[1,0],[4,-2]]), label='Image2')
self.map1 = HoloMap({1:self.image1, 2:self.image2}, label='TestMap')
self.unicode_table = ItemTable([('β','Δ1'), ('°C', '3×4')],
label='Poincaré', group='α Festkörperphysik')
self.renderer = MPLRenderer.instance()
def test_columns_collapse_heterogeneous(self):
collapsed = HoloMap(
{
i: Dataset(
{
'x': self.xs,
'y': self.ys * i
}, kdims=['x'], vdims=['y'])
for i in range(10)
},
kdims=['z']).collapse('z', np.mean)
expected = Dataset({
'x': self.xs,
'y': self.ys * 4.5
},
kdims=['x'],
vdims=['y'])
self.compare_dataset(collapsed, expected)
def setUp(self):
if 'matplotlib' not in Store.renderers and pn is not None:
raise SkipTest("Matplotlib and Panel required to test rendering.")
self.basename = 'no-file'
self.image1 = Image(np.array([[0,1],[2,3]]), label='Image1')
self.image2 = Image(np.array([[1,0],[4,-2]]), label='Image2')
self.map1 = HoloMap({1:self.image1, 2:self.image2}, label='TestMap')
self.unicode_table = ItemTable([('β','Δ1'), ('°C', '3×4')],
label='Poincaré', group='α Festkörperphysik')
self.renderer = MPLRenderer.instance()
self.nbcontext = Renderer.notebook_context
self.comm_manager = Renderer.comm_manager
with param.logging_level('ERROR'):
Renderer.notebook_context = False
Renderer.comm_manager = CommManager
