class Binned2DTest(ComparisonTestCase):
def setUp(self):
n = 4
self.xs = np.logspace(1, 3, n)
self.ys = np.linspace(1, 10, n)
self.zs = np.arange((n - 1)**2).reshape(n - 1, n - 1)
self.dataset2d = QuadMesh((self.xs, self.ys, self.zs))
def test_qmesh_index_lower_left(self):
self.assertEqual(self.dataset2d[10, 1], 0)
def test_qmesh_index_lower_right(self):
self.assertEqual(self.dataset2d[800, 3.9], 2)
def test_qmesh_index_top_left(self):
self.assertEqual(self.dataset2d[10, 9.9], 6)
def test_qmesh_index_top_right(self):
self.assertEqual(self.dataset2d[216, 7], 8)
def test_qmesh_index_xcoords(self):
sliced = QuadMesh((self.xs[2:4], self.ys, self.zs[:, 2:3]))
self.assertEqual(self.dataset2d[300, :], sliced)
def test_qmesh_index_ycoords(self):
sliced = QuadMesh((self.xs, self.ys[-2:], self.zs[-1:, :]))
self.assertEqual(self.dataset2d[:, 7], sliced)
def test_qmesh_slice_xcoords(self):
sliced = QuadMesh((self.xs[1:], self.ys, self.zs[:, 1:]))
self.assertEqual(self.dataset2d[100:1000, :], sliced)
def test_qmesh_slice_ycoords(self):
sliced = QuadMesh((self.xs, self.ys[:-1], self.zs[:-1, :]))
self.assertEqual(self.dataset2d[:, 2:7], sliced)
def test_qmesh_slice_xcoords_ycoords(self):
sliced = QuadMesh((self.xs[1:], self.ys[:-1], self.zs[:-1, 1:]))
self.assertEqual(self.dataset2d[100:1000, 2:7], sliced)
def test_groupby_xdim(self):
grouped = self.dataset2d.groupby('x', group_type=Dataset)
holomap = HoloMap(
{(self.xs[i] + np.diff(self.xs[i:i + 2]) / 2.)[0]: Dataset(
(self.ys, self.zs[:, i]), 'y', 'z')
for i in range(3)},
kdims=['x'])
self.assertEqual(grouped, holomap)
def test_groupby_ydim(self):
grouped = self.dataset2d.groupby('y', group_type=Dataset)
holomap = HoloMap(
{
self.ys[i:i + 2].mean(): Dataset(
(self.xs, self.zs[i]), 'x', 'z')
for i in range(3)
},
kdims=['y'])
self.assertEqual(grouped, holomap)
def test_quadmesh_invert_axes(self):
arr = np.array([[0, 1, 2], [3, 4, 5]])
qmesh = QuadMesh(Image(arr)).opts(plot=dict(invert_axes=True, tools=['hover']))
plot = bokeh_renderer.get_plot(qmesh)
source = plot.handles['source']
self.assertEqual(source.data['z'], qmesh.dimension_values(2, flat=False).flatten())
self.assertEqual(source.data['x'], qmesh.dimension_values(0))
self.assertEqual(source.data['y'], qmesh.dimension_values(1))
def test_quadmesh_invert_axes(self):
arr = np.array([[0, 1, 2], [3, 4, 5]])
qmesh = QuadMesh(Image(arr)).opts(plot=dict(invert_axes=True, tools=['hover']))
plot = bokeh_renderer.get_plot(qmesh)
source = plot.handles['source']
self.assertEqual(source.data['z'], qmesh.dimension_values(2, flat=False).flatten())
self.assertEqual(source.data['x'], qmesh.dimension_values(0))
self.assertEqual(source.data['y'], qmesh.dimension_values(1))
def test_datetime64_bins_range(self):
xs = [np.datetime64(dt.datetime(2018, 1, i)) for i in range(1, 11)]
ys = np.arange(10)
array = np.random.rand(10, 10)
ds = QuadMesh((xs, ys, array))
self.assertEqual(ds.interface.datatype, 'xarray')
expected = (np.datetime64(dt.datetime(2017, 12, 31, 12, 0)),
np.datetime64(dt.datetime(2018, 1, 10, 12, 0)))
self.assertEqual(ds.range('x'), expected)
def test_datetime64_bins_range(self):
xs = [np.datetime64(dt.datetime(2018, 1, i)) for i in range(1, 11)]
ys = np.arange(10)
array = np.random.rand(10, 10)
ds = QuadMesh((xs, ys, array))
self.assertEqual(ds.interface.datatype, 'xarray')
expected = (np.datetime64(dt.datetime(2017, 12, 31, 12, 0)),
np.datetime64(dt.datetime(2018, 1, 10, 12, 0)))
self.assertEqual(ds.range('x'), expected)
def test_cast_image_to_quadmesh(self):
img = Image(self.array1, kdims=['a', 'b'], vdims=['c'], group='A', label='B')
qmesh = QuadMesh(img)
self.assertEqual(qmesh.dimension_values(0, False), np.array([-0.333333, 0., 0.333333]))
self.assertEqual(qmesh.dimension_values(1, False), np.array([-0.25, 0.25]))
self.assertEqual(qmesh.dimension_values(2, flat=False), self.array1[::-1])
self.assertEqual(qmesh.kdims, img.kdims)
self.assertEqual(qmesh.vdims, img.vdims)
self.assertEqual(qmesh.group, img.group)
self.assertEqual(qmesh.label, img.label)
def test_quadmesh_inverted_coords(self):
xs = [0, 1, 2]
ys = [2, 1, 0]
qmesh = QuadMesh((xs, ys, np.random.rand(3, 3)))
plot = bokeh_renderer.get_plot(qmesh)
source = plot.handles['source']
self.assertEqual(source.data['z'], qmesh.dimension_values(2, flat=False).T.flatten())
self.assertEqual(source.data['left'], np.array([-0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 1.5, 1.5, 1.5]))
self.assertEqual(source.data['right'], np.array([0.5, 0.5, 0.5, 1.5, 1.5, 1.5, 2.5, 2.5, 2.5]))
self.assertEqual(source.data['top'], np.array([0.5, 1.5, 2.5, 0.5, 1.5, 2.5, 0.5, 1.5, 2.5]))
self.assertEqual(source.data['bottom'], np.array([-0.5, 0.5, 1.5, -0.5, 0.5, 1.5, -0.5, 0.5, 1.5]))
def test_quadmesh_to_trimesh(self):
qmesh = QuadMesh(([0, 1], [0, 1], np.array([[0, 1], [2, 3]])))
trimesh = qmesh.trimesh()
simplices = np.array([[0, 1, 3, 0], [1, 2, 4, 2], [3, 4, 6, 1],
[4, 5, 7, 3], [4, 3, 1, 0], [5, 4, 2, 2],
[7, 6, 4, 1], [8, 7, 5, 3]])
vertices = np.array([(-0.5, -0.5), (-0.5, 0.5), (-0.5, 1.5),
(0.5, -0.5), (0.5, 0.5), (0.5, 1.5), (1.5, -0.5),
(1.5, 0.5), (1.5, 1.5)])
self.assertEqual(trimesh.array(), simplices)
self.assertEqual(trimesh.nodes.array([0, 1]), vertices)
class Binned2DTest(ComparisonTestCase):
def setUp(self):
n = 4
self.xs = np.logspace(1, 3, n)
self.ys = np.linspace(1, 10, n)
self.zs = np.arange((n-1)**2).reshape(n-1, n-1)
self.dataset2d = QuadMesh((self.xs, self.ys, self.zs))
def test_qmesh_index_lower_left(self):
self.assertEqual(self.dataset2d[10, 1], 0)
def test_qmesh_index_lower_right(self):
self.assertEqual(self.dataset2d[800, 3.9], 2)
def test_qmesh_index_top_left(self):
self.assertEqual(self.dataset2d[10, 9.9], 6)
def test_qmesh_index_top_right(self):
self.assertEqual(self.dataset2d[216, 7], 8)
def test_qmesh_index_xcoords(self):
sliced = QuadMesh((self.xs[2:4], self.ys, self.zs[:, 2:3]))
self.assertEqual(self.dataset2d[300, :], sliced)
def test_qmesh_index_ycoords(self):
sliced = QuadMesh((self.xs, self.ys[-2:], self.zs[-1:, :]))
self.assertEqual(self.dataset2d[:, 7], sliced)
def test_qmesh_slice_xcoords(self):
sliced = QuadMesh((self.xs[1:], self.ys, self.zs[:, 1:]))
self.assertEqual(self.dataset2d[100:1000, :], sliced)
def test_qmesh_slice_ycoords(self):
sliced = QuadMesh((self.xs, self.ys[:-1], self.zs[:-1, :]))
self.assertEqual(self.dataset2d[:, 2:7], sliced)
def test_qmesh_slice_xcoords_ycoords(self):
sliced = QuadMesh((self.xs[1:], self.ys[:-1], self.zs[:-1, 1:]))
self.assertEqual(self.dataset2d[100:1000, 2:7], sliced)
def test_groupby_xdim(self):
grouped = self.dataset2d.groupby('x', group_type=Dataset)
holomap = HoloMap({(self.xs[i]+np.diff(self.xs[i:i+2])/2.)[0]:
Dataset((self.ys, self.zs[:, i]), 'y', 'z')
for i in range(3)}, kdims=['x'])
self.assertEqual(grouped, holomap)
def test_groupby_ydim(self):
grouped = self.dataset2d.groupby('y', group_type=Dataset)
holomap = HoloMap({self.ys[i:i+2].mean(): Dataset((self.xs, self.zs[i]), 'x', 'z')
for i in range(3)}, kdims=['y'])
self.assertEqual(grouped, holomap)
def test_quadmesh_nodata_uint(self):
arr = np.array([[0, 1, 2], [3, 4, 5]], dtype='uint32')
qmesh = QuadMesh(Image(arr)).opts(nodata=0)
plot = mpl_renderer.get_plot(qmesh)
artist = plot.handles['artist']
self.assertEqual(artist.get_array().data,
np.array([3, 4, 5, np.NaN, 1, 2]))
def test_quadmesh_to_trimesh(self):
qmesh = QuadMesh(([0, 1], [0, 1], np.array([[0, 1], [2, 3]])))
trimesh = qmesh.trimesh()
simplices = np.array([[0, 1, 3, 0],
[1, 2, 4, 2],
[3, 4, 6, 1],
[4, 5, 7, 3],
[4, 3, 1, 0],
[5, 4, 2, 2],
[7, 6, 4, 1],
[8, 7, 5, 3]])
vertices = np.array([(-0.5, -0.5), (-0.5, 0.5), (-0.5, 1.5),
(0.5, -0.5), (0.5, 0.5), (0.5, 1.5),
(1.5, -0.5), (1.5, 0.5), (1.5, 1.5)])
self.assertEqual(trimesh.array(), simplices)
self.assertEqual(trimesh.nodes.array([0, 1]), vertices)
def test_quadmesh_selection_inverted(self):
n = 4
coords = np.linspace(-1.5,1.5,n)
X,Y = np.meshgrid(coords, coords);
Qx = np.cos(Y) - np.cos(X)
Qy = np.sin(Y) + np.sin(X)
Z = np.sqrt(X**2 + Y**2)
qmesh = QuadMesh((Qx, Qy, Z)).opts(invert_axes=True)
expr, bbox, region = qmesh._get_selection_expr_for_stream_value(bounds=(0, -0.5, 0.7, 1.5))
self.assertEqual(bbox, {'x': (-0.5, 1.5), 'y': (0, 0.7)})
self.assertEqual(expr.apply(qmesh, expanded=True, flat=False), np.array([
[False, False, False, True],
[False, False, True, True],
[False, True, False, False],
[True, False, False, False]
]))
self.assertEqual(region, Rectangles([(0, -0.5, 0.7, 1.5)]) * Path([]))
def test_quadmesh_nodata_uint(self):
img = QuadMesh(
([1, 2, 4], [0, 1], np.array([[0, 1, 2], [2, 3, 4]],
dtype='uint32'))).opts(nodata=0)
state = self._get_plot_state(img)
self.assertEqual(state['data'][0]['type'], 'heatmap')
self.assertEqual(state['data'][0]['z'],
np.array([[np.NaN, 1, 2], [2, 3, 4]]))
def test_quadmesh_colorbar(self):
n = 21
xs = np.logspace(1, 3, n)
ys = np.linspace(1, 10, n)
qmesh = QuadMesh((xs, ys, np.random.rand(n-1, n-1))).options(colorbar=True)
plot = bokeh_renderer.get_plot(qmesh)
self.assertIsInstance(plot.handles['colorbar'], ColorBar)
self.assertIs(plot.handles['colorbar'].color_mapper, plot.handles['color_mapper'])
def test_quadmesh_nodata_uint(self):
xs = [0, 1, 2]
ys = [2, 1, 0]
data = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype='uint32')
flattened = np.array([6, 3, np.NaN, 7, 4, 1, 8, 5, 2])
qmesh = QuadMesh((xs, ys, data)).opts(nodata=0)
plot = bokeh_renderer.get_plot(qmesh)
source = plot.handles['source']
self.assertEqual(source.data['z'], flattened)
def test_quadmesh_inverted_coords(self):
xs = [0, 1, 2]
ys = [2, 1, 0]
qmesh = QuadMesh((xs, ys, np.random.rand(3, 3)))
plot = bokeh_renderer.get_plot(qmesh)
source = plot.handles['source']
self.assertEqual(source.data['z'],
qmesh.dimension_values(2, flat=False).T.flatten())
self.assertEqual(
source.data['left'],
np.array([-0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 1.5, 1.5, 1.5]))
self.assertEqual(
source.data['right'],
np.array([0.5, 0.5, 0.5, 1.5, 1.5, 1.5, 2.5, 2.5, 2.5]))
self.assertEqual(
source.data['top'],
np.array([0.5, 1.5, 2.5, 0.5, 1.5, 2.5, 0.5, 1.5, 2.5]))
self.assertEqual(
source.data['bottom'],
np.array([-0.5, 0.5, 1.5, -0.5, 0.5, 1.5, -0.5, 0.5, 1.5]))
def test_quadmesh_state(self):
img = QuadMesh(([1, 2, 4], [0, 1], np.array([[0, 1, 2], [2, 3, 4]])))
state = self._get_plot_state(img)
self.assertEqual(state['data'][0]['type'], 'heatmap')
self.assertEqual(state['data'][0]['x'], np.array([0.5, 1.5, 3., 5.]))
self.assertEqual(state['data'][0]['y'], np.array([-0.5, .5, 1.5]))
self.assertEqual(state['data'][0]['z'], np.array([[0, 1, 2], [2, 3,
4]]))
self.assertEqual(state['data'][0]['zmin'], 0)
self.assertEqual(state['data'][0]['zmax'], 4)
self.assertEqual(state['layout']['xaxis']['range'], [0.5, 5])
self.assertEqual(state['layout']['yaxis']['range'], [-0.5, 1.5])
def test_quadmesh_state_inverted(self):
img = QuadMesh(
([1, 2, 4], [0, 1], np.array([[0, 1, 2],
[2, 3,
4]]))).options(invert_axes=True)
state = self._get_plot_state(img)
self.assertEqual(state['data'][0]['x'], np.array([-0.5, .5, 1.5]))
self.assertEqual(state['data'][0]['y'], np.array([0.5, 1.5, 3., 5.]))
self.assertEqual(state['data'][0]['z'],
np.array([[0, 1, 2], [2, 3, 4]]).T)
self.assertEqual(state['data'][0]['zmin'], 0)
self.assertEqual(state['data'][0]['zmax'], 4)
self.assertEqual(state['layout']['xaxis']['range'], [-0.5, 1.5])
self.assertEqual(state['layout']['yaxis']['range'], [0.5, 5])
def test_cast_image_to_quadmesh(self):
img = Image(self.array1,
kdims=['a', 'b'],
vdims=['c'],
group='A',
label='B')
qmesh = QuadMesh(img)
self.assertEqual(qmesh.data[0],
np.array([-0.5, -0.166667, 0.166667, 0.5]))
self.assertEqual(qmesh.data[1], np.array([-0.5, 0, 0.5]))
self.assertEqual(qmesh.data[2], self.array1[::-1])
self.assertEqual(qmesh.kdims, img.kdims)
self.assertEqual(qmesh.vdims, img.vdims)
self.assertEqual(qmesh.group, img.group)
self.assertEqual(qmesh.label, img.label)
def test_quadmesh_invert_axes(self):
arr = np.array([[0, 1, 2], [3, 4, 5]])
qmesh = QuadMesh(Image(arr)).opts(plot=dict(invert_axes=True))
plot = mpl_renderer.get_plot(qmesh)
artist = plot.handles['artist']
self.assertEqual(artist.get_array().data, arr.T[:, ::-1].flatten())
def test_qmesh_transform_replace_vdim(self):
transformed = self.dataset2d.transform(z=dim('z') * 2)
expected = QuadMesh((self.xs, self.ys, self.zs * 2))
self.assertEqual(expected, transformed)
def setUp(self):
n = 4
self.xs = np.logspace(1, 3, n)
self.ys = np.linspace(1, 10, n)
self.zs = np.arange((n-1)**2).reshape(n-1, n-1)
self.dataset2d = QuadMesh((self.xs, self.ys, self.zs))
def test_qmesh_slice_xcoords_ycoords(self):
sliced = QuadMesh((self.xs[1:], self.ys[:-1], self.zs[:-1, 1:]))
self.assertEqual(self.dataset2d[100:1000, 2:7], sliced)
def test_qmesh_slice_ycoords(self):
sliced = QuadMesh((self.xs, self.ys[:-1], self.zs[:-1, :]))
self.assertEqual(self.dataset2d[:, 2:7], sliced)
def test_qmesh_index_ycoords(self):
sliced = QuadMesh((self.xs, self.ys[-2:], self.zs[-1:, :]))
self.assertEqual(self.dataset2d[:, 7], sliced)
def test_qmesh_index_xcoords(self):
sliced = QuadMesh((self.xs[2:4], self.ys, self.zs[:, 2:3]))
self.assertEqual(self.dataset2d[300, :], sliced)
def setUp(self):
n = 4
self.xs = np.logspace(1, 3, n)
self.ys = np.linspace(1, 10, n)
self.zs = np.arange((n-1)**2).reshape(n-1, n-1)
self.dataset2d = QuadMesh((self.xs, self.ys, self.zs))
def test_visible(self):
element = QuadMesh(
([1, 2, 4], [0, 1], np.array([[0, 1, 2],
[2, 3, 4]]))).options(visible=False)
state = self._get_plot_state(element)
self.assertEqual(state['data'][0]['visible'], False)
def test_quadmesh_colormapping(self):
n = 21
xs = np.logspace(1, 3, n)
ys = np.linspace(1, 10, n)
qmesh = QuadMesh((xs, ys, np.random.rand(n - 1, n - 1)))
self._test_colormapping(qmesh, 2)