def setUp(self):
super(TestBokehTriMeshPlot, self).setUp()
self.nodes = [(0, 0, 0), (0.5, 1, 1), (1., 0, 2), (1.5, 1, 3)]
self.simplices = [(0, 1, 2, 0), (1, 2, 3, 1)]
self.trimesh = TriMesh((self.simplices, self.nodes))
self.trimesh_weighted = TriMesh((self.simplices, self.nodes), vdims='weight')
def setUp(self):
super(TestMplTriMeshPlot, self).setUp()
self.nodes = [(0, 0, 0), (0.5, 1, 1), (1., 0, 2), (1.5, 1, 3)]
self.simplices = [(0, 1, 2, 0), (1, 2, 3, 1)]
self.trimesh = TriMesh((self.simplices, self.nodes))
self.trimesh_weighted = TriMesh((self.simplices, self.nodes), vdims='weight')
def setUp(self):
if not bokeh_renderer:
raise SkipTest("Bokeh required to test plot instantiation")
self.previous_backend = Store.current_backend
Store.current_backend = 'bokeh'
self.default_comm = bokeh_renderer.comms['default']
self.nodes = [(0, 0, 0), (0.5, 1, 1), (1., 0, 2), (1.5, 1, 3)]
self.simplices = [(0, 1, 2, 0), (1, 2, 3, 1)]
self.trimesh = TriMesh((self.simplices, self.nodes))
self.trimesh_weighted = TriMesh((self.simplices, self.nodes),
vdims='weight')
class TestMplTriMeshPlot(TestMPLPlot):
def setUp(self):
super(TestMplTriMeshPlot, self).setUp()
self.nodes = [(0, 0, 0), (0.5, 1, 1), (1., 0, 2), (1.5, 1, 3)]
self.simplices = [(0, 1, 2, 0), (1, 2, 3, 1)]
self.trimesh = TriMesh((self.simplices, self.nodes))
self.trimesh_weighted = TriMesh((self.simplices, self.nodes), vdims='weight')
def test_plot_simple_trimesh(self):
plot = mpl_renderer.get_plot(self.trimesh)
nodes = plot.handles['nodes']
edges = plot.handles['edges']
self.assertIsInstance(edges, LineCollection)
self.assertEqual(nodes.get_offsets(), self.trimesh.nodes.array([0, 1]))
self.assertEqual([p.vertices for p in edges.get_paths()],
[p.array() for p in self.trimesh._split_edgepaths.split()])
def test_plot_simple_trimesh_filled(self):
plot = mpl_renderer.get_plot(self.trimesh.opts(plot=dict(filled=True)))
nodes = plot.handles['nodes']
edges = plot.handles['edges']
self.assertIsInstance(edges, PolyCollection)
self.assertEqual(nodes.get_offsets(), self.trimesh.nodes.array([0, 1]))
paths = self.trimesh._split_edgepaths.split(datatype='array')
self.assertEqual([p.vertices[:4] for p in edges.get_paths()],
paths)
def test_plot_trimesh_colored_edges(self):
opts = dict(plot=dict(edge_color_index='weight'), style=dict(edge_cmap='Greys'))
plot = mpl_renderer.get_plot(self.trimesh_weighted.opts(**opts))
edges = plot.handles['edges']
colors = np.array([[ 1., 1., 1., 1.],
[ 0., 0., 0., 1.]])
self.assertEqual(edges.get_edgecolors(), colors)
def test_plot_trimesh_categorically_colored_edges(self):
opts = dict(plot=dict(edge_color_index='node1'), style=dict(edge_color=Cycle('Set1')))
plot = mpl_renderer.get_plot(self.trimesh_weighted.opts(**opts))
edges = plot.handles['edges']
colors = np.array([[0.894118, 0.101961, 0.109804, 1.],
[0.215686, 0.494118, 0.721569, 1.]])
self.assertEqual(edges.get_edgecolors(), colors)
def test_plot_trimesh_categorically_colored_edges_filled(self):
opts = dict(plot=dict(edge_color_index='node1', filled=True),
style=dict(edge_color=Cycle('Set1')))
plot = mpl_renderer.get_plot(self.trimesh_weighted.opts(**opts))
edges = plot.handles['edges']
colors = np.array([[0.894118, 0.101961, 0.109804, 1.],
[0.215686, 0.494118, 0.721569, 1.]])
self.assertEqual(edges.get_facecolors(), colors)
def test_trimesh_op_edge_alpha(self):
edges = [(0, 1, 2, 0.7), (1, 2, 3, 0.3)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes),
vdims='alpha').options(edge_alpha='alpha')
with self.assertRaises(Exception):
mpl_renderer.get_plot(trimesh)
def test_trimesh_op_edge_line_width(self):
edges = [(0, 1, 2, 7), (1, 2, 3, 3)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='line_width').options(edge_linewidth='line_width')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_linewidths(), [7, 3])
def test_trimesh_op_node_size(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 3), (0, 0, 1, 2), (0, 1, 2, 8), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='size'))).options(node_size='size')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_sizes(), np.array([9, 4, 64, 16]))
def test_trimesh_op_node_line_width(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 0.2), (0, 0, 1, 0.6), (0, 1, 2, 1), (1, 0, 3, 0.3)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='line_width'))).options(node_linewidth='line_width')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_linewidths(), [0.2, 0.6, 1, 0.3])
def test_trimesh_op_edge_color_linear_mean_node(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 2), (0, 0, 1, 1), (0, 1, 2, 3), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_array(), np.array([2, 8/3.]))
self.assertEqual(artist.get_clim(), (1, 4))
def test_trimesh_op_edge_color_categorical(self):
edges = [(0, 1, 2, 'A'), (1, 2, 3, 'B')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_array(), np.array([0, 1]))
self.assertEqual(artist.get_clim(), (0, 1))
def test_trimesh_op_edge_color(self):
edges = [(0, 1, 2, 'red'), (1, 2, 3, 'blue')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_edgecolors(), np.array([
[1, 0, 0, 1], [0, 0, 1, 1]]))
def test_trimesh_op_node_color(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 'red'), (0, 0, 1, 'green'), (0, 1, 2, 'blue'), (1, 0, 3, 'black')]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_facecolors(),
np.array([[1, 0, 0, 1], [0, 0.501961, 0, 1], [0, 0, 1, 1], [0, 0, 0, 1]]))
def test_trimesh_op_edge_color_linear(self):
edges = [(0, 1, 2, 2.4), (1, 2, 3, 3.6)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_array(), np.array([2.4, 3.6]))
self.assertEqual(artist.get_clim(), (2.4, 3.6))
def test_trimesh_op_node_size(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 3), (0, 0, 1, 2), (0, 1, 2, 8), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='size'))).options(node_size='size')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
self.assertEqual(glyph.size, {'field': 'node_size'})
self.assertEqual(cds.data['node_size'], np.array([3, 2, 8, 4]))
def test_trimesh_op_edge_line_width(self):
edges = [(0, 1, 2, 7), (1, 2, 3, 3)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='line_width').options(edge_line_width='line_width')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertEqual(glyph.line_width, {'field': 'edge_line_width'})
self.assertEqual(cds.data['edge_line_width'], np.array([7, 3]))
def test_trimesh_op_edge_color(self):
edges = [(0, 1, 2, 'red'), (1, 2, 3, 'blue')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertEqual(glyph.line_color, {'field': 'edge_color'})
self.assertEqual(cds.data['edge_color'], np.array(['red', 'blue']))
def test_trimesh_op_node_line_width(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 0.2), (0, 0, 1, 0.6), (0, 1, 2, 1), (1, 0, 3, 0.3)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='line_width'))).options(node_line_width='line_width')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
self.assertEqual(glyph.line_width, {'field': 'node_line_width'})
self.assertEqual(cds.data['node_line_width'], np.array([0.2, 0.6, 1, 0.3]))
def test_trimesh_op_node_color(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 'red'), (0, 0, 1, 'green'), (0, 1, 2, 'blue'), (1, 0, 3, 'black')]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
self.assertEqual(glyph.fill_color, {'field': 'node_color'})
self.assertEqual(glyph.line_color, 'black')
self.assertEqual(cds.data['node_color'], np.array(['red', 'green', 'blue', 'black']))
def test_trimesh_op_node_color_categorical(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 'B'), (0, 0, 1, 'C'), (0, 1, 2, 'A'), (1, 0, 3, 'B')]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
cmapper = plot.handles['node_color_color_mapper']
self.assertEqual(glyph.fill_color, {'field': 'node_color', 'transform': cmapper})
self.assertEqual(glyph.line_color, 'black')
self.assertEqual(cds.data['node_color'], np.array(['B', 'C', 'A', 'B']))
def test_trimesh_op_edge_color_categorical(self):
edges = [(0, 1, 2, 'A'), (1, 2, 3, 'B')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
cmapper = plot.handles['edge_color_color_mapper']
self.assertEqual(glyph.line_color, {'field': 'edge_color', 'transform': cmapper})
self.assertEqual(cds.data['edge_color'], np.array(['A', 'B']))
self.assertEqual(cmapper.factors, ['A', 'B'])
def test_trimesh_op_edge_color_linear_mean_node(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 2), (0, 0, 1, 1), (0, 1, 2, 3), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(edge_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
cmapper = plot.handles['edge_color_color_mapper']
self.assertEqual(glyph.line_color, {'field': 'edge_color', 'transform': cmapper})
self.assertEqual(cds.data['edge_color'], np.array([2, 8/3.]))
self.assertEqual(cmapper.low, 1)
self.assertEqual(cmapper.high, 4)
def test_trimesh_op_edge_color_linear_filled(self):
edges = [(0, 1, 2, 2.4), (1, 2, 3, 3.6)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color', filled=True)
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['patches_1_source']
glyph = plot.handles['patches_1_glyph']
cmapper = plot.handles['edge_color_color_mapper']
self.assertEqual(glyph.fill_color, {'field': 'edge_color', 'transform': cmapper})
self.assertEqual(glyph.line_color, 'black')
self.assertEqual(cds.data['edge_color'], np.array([2.4, 3.6]))
self.assertEqual(cmapper.low, 2.4)
self.assertEqual(cmapper.high, 3.6)
def test_trimesh_op_node_alpha(self):
import matplotlib as mpl
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 0.2), (0, 0, 1, 0.6), (0, 1, 2, 1),
(1, 0, 3, 0.3)]
trimesh = TriMesh(
(edges, Nodes(nodes, vdims='alpha'))).options(node_alpha='alpha')
if LooseVersion(mpl.__version__) < LooseVersion("3.4.0"):
# Python 3.6 only support up to matplotlib 3.3
with self.assertRaises(Exception):
mpl_renderer.get_plot(trimesh)
else:
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_alpha(), np.array([0.2, 0.6, 1, 0.3]))
class TestBokehTriMeshPlot(TestBokehPlot):
def setUp(self):
super(TestBokehTriMeshPlot, self).setUp()
self.nodes = [(0, 0, 0), (0.5, 1, 1), (1., 0, 2), (1.5, 1, 3)]
self.simplices = [(0, 1, 2, 0), (1, 2, 3, 1)]
self.trimesh = TriMesh((self.simplices, self.nodes))
self.trimesh_weighted = TriMesh((self.simplices, self.nodes), vdims='weight')
def test_plot_simple_trimesh(self):
plot = bokeh_renderer.get_plot(self.trimesh)
node_source = plot.handles['scatter_1_source']
edge_source = plot.handles['multi_line_1_source']
layout_source = plot.handles['layout_source']
self.assertEqual(node_source.data['index'], np.arange(4))
self.assertEqual(edge_source.data['start'], np.arange(2))
self.assertEqual(edge_source.data['end'], np.arange(1, 3))
layout = {str(int(z)): (x, y) for x, y, z in self.trimesh.nodes.array()}
self.assertEqual(layout_source.graph_layout, layout)
def test_plot_simple_trimesh_filled(self):
plot = bokeh_renderer.get_plot(self.trimesh.opts(plot=dict(filled=True)))
node_source = plot.handles['scatter_1_source']
edge_source = plot.handles['patches_1_source']
layout_source = plot.handles['layout_source']
self.assertIsInstance(plot.handles['patches_1_glyph'], Patches)
self.assertEqual(node_source.data['index'], np.arange(4))
self.assertEqual(edge_source.data['start'], np.arange(2))
self.assertEqual(edge_source.data['end'], np.arange(1, 3))
layout = {str(int(z)): (x, y) for x, y, z in self.trimesh.nodes.array()}
self.assertEqual(layout_source.graph_layout, layout)
def test_trimesh_edges_categorical_colormapped(self):
g = self.trimesh.opts(plot=dict(edge_color_index='node1'),
style=dict(edge_cmap=['#FFFFFF', '#000000']))
plot = bokeh_renderer.get_plot(g)
print(plot.handles)
cmapper = plot.handles['edge_colormapper']
edge_source = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertIsInstance(cmapper, CategoricalColorMapper)
factors = ['0', '1', '2', '3']
self.assertEqual(cmapper.factors, factors)
self.assertEqual(edge_source.data['node1_str__'], ['0', '1'])
self.assertEqual(glyph.line_color, {'field': 'node1_str__', 'transform': cmapper})
def test_trimesh_nodes_numerically_colormapped(self):
g = self.trimesh_weighted.opts(plot=dict(edge_color_index='weight'),
style=dict(edge_cmap=['#FFFFFF', '#000000']))
plot = bokeh_renderer.get_plot(g)
cmapper = plot.handles['edge_colormapper']
edge_source = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertIsInstance(cmapper, LinearColorMapper)
self.assertEqual(cmapper.low, 0)
self.assertEqual(cmapper.high, 1)
self.assertEqual(edge_source.data['weight'], np.array([0, 1]))
self.assertEqual(glyph.line_color, {'field': 'weight', 'transform': cmapper})
###########################
# Styling mapping #
###########################
def test_trimesh_op_node_color(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 'red'), (0, 0, 1, 'green'), (0, 1, 2, 'blue'), (1, 0, 3, 'black')]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
self.assertEqual(glyph.fill_color, {'field': 'node_color'})
self.assertEqual(glyph.line_color, 'black')
self.assertEqual(cds.data['node_color'], np.array(['red', 'green', 'blue', 'black']))
def test_trimesh_op_node_color_linear(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 2), (0, 0, 1, 1), (0, 1, 2, 3), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
cmapper = plot.handles['node_color_color_mapper']
self.assertEqual(glyph.fill_color, {'field': 'node_color', 'transform': cmapper})
self.assertEqual(glyph.line_color, 'black')
self.assertEqual(cds.data['node_color'], np.array([2, 1, 3, 4]))
self.assertEqual(cmapper.low, 1)
self.assertEqual(cmapper.high, 4)
def test_trimesh_op_node_color_categorical(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 'B'), (0, 0, 1, 'C'), (0, 1, 2, 'A'), (1, 0, 3, 'B')]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
cmapper = plot.handles['node_color_color_mapper']
self.assertEqual(glyph.fill_color, {'field': 'node_color', 'transform': cmapper})
self.assertEqual(glyph.line_color, 'black')
self.assertEqual(cds.data['node_color'], np.array(['B', 'C', 'A', 'B']))
def test_trimesh_op_node_size(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 3), (0, 0, 1, 2), (0, 1, 2, 8), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='size'))).options(node_size='size')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
self.assertEqual(glyph.size, {'field': 'node_size'})
self.assertEqual(cds.data['node_size'], np.array([3, 2, 8, 4]))
def test_trimesh_op_node_alpha(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 0.2), (0, 0, 1, 0.6), (0, 1, 2, 1), (1, 0, 3, 0.3)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='alpha'))).options(node_alpha='alpha')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
self.assertEqual(glyph.fill_alpha, {'field': 'node_alpha'})
self.assertEqual(glyph.line_alpha, {'field': 'node_alpha'})
self.assertEqual(cds.data['node_alpha'], np.array([0.2, 0.6, 1, 0.3]))
def test_trimesh_op_node_line_width(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 0.2), (0, 0, 1, 0.6), (0, 1, 2, 1), (1, 0, 3, 0.3)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='line_width'))).options(node_line_width='line_width')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
self.assertEqual(glyph.line_width, {'field': 'node_line_width'})
self.assertEqual(cds.data['node_line_width'], np.array([0.2, 0.6, 1, 0.3]))
def test_trimesh_op_edge_color_linear_mean_node(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 2), (0, 0, 1, 1), (0, 1, 2, 3), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(edge_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
cmapper = plot.handles['edge_color_color_mapper']
self.assertEqual(glyph.line_color, {'field': 'edge_color', 'transform': cmapper})
self.assertEqual(cds.data['edge_color'], np.array([2, 8/3.]))
self.assertEqual(cmapper.low, 1)
self.assertEqual(cmapper.high, 4)
def test_trimesh_op_edge_color(self):
edges = [(0, 1, 2, 'red'), (1, 2, 3, 'blue')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertEqual(glyph.line_color, {'field': 'edge_color'})
self.assertEqual(cds.data['edge_color'], np.array(['red', 'blue']))
def test_trimesh_op_edge_color_linear(self):
edges = [(0, 1, 2, 2.4), (1, 2, 3, 3.6)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
cmapper = plot.handles['edge_color_color_mapper']
self.assertEqual(glyph.line_color, {'field': 'edge_color', 'transform': cmapper})
self.assertEqual(cds.data['edge_color'], np.array([2.4, 3.6]))
self.assertEqual(cmapper.low, 2.4)
self.assertEqual(cmapper.high, 3.6)
def test_trimesh_op_edge_color_linear_filled(self):
edges = [(0, 1, 2, 2.4), (1, 2, 3, 3.6)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color', filled=True)
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['patches_1_source']
glyph = plot.handles['patches_1_glyph']
cmapper = plot.handles['edge_color_color_mapper']
self.assertEqual(glyph.fill_color, {'field': 'edge_color', 'transform': cmapper})
self.assertEqual(glyph.line_color, 'black')
self.assertEqual(cds.data['edge_color'], np.array([2.4, 3.6]))
self.assertEqual(cmapper.low, 2.4)
self.assertEqual(cmapper.high, 3.6)
def test_trimesh_op_edge_color_categorical(self):
edges = [(0, 1, 2, 'A'), (1, 2, 3, 'B')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
cmapper = plot.handles['edge_color_color_mapper']
self.assertEqual(glyph.line_color, {'field': 'edge_color', 'transform': cmapper})
self.assertEqual(cds.data['edge_color'], np.array(['A', 'B']))
self.assertEqual(cmapper.factors, ['A', 'B'])
def test_trimesh_op_edge_alpha(self):
edges = [(0, 1, 2, 0.7), (1, 2, 3, 0.3)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='alpha').options(edge_alpha='alpha')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertEqual(glyph.line_alpha, {'field': 'edge_alpha'})
self.assertEqual(cds.data['edge_alpha'], np.array([0.7, 0.3]))
def test_trimesh_op_edge_line_width(self):
edges = [(0, 1, 2, 7), (1, 2, 3, 3)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='line_width').options(edge_line_width='line_width')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertEqual(glyph.line_width, {'field': 'edge_line_width'})
self.assertEqual(cds.data['edge_line_width'], np.array([7, 3]))
class TestBokehTriMeshPlots(ComparisonTestCase):
def setUp(self):
if not bokeh_renderer:
raise SkipTest("Bokeh required to test plot instantiation")
self.previous_backend = Store.current_backend
Store.current_backend = 'bokeh'
self.default_comm = bokeh_renderer.comms['default']
self.nodes = [(0, 0, 0), (0.5, 1, 1), (1., 0, 2), (1.5, 1, 3)]
self.simplices = [(0, 1, 2, 0), (1, 2, 3, 1)]
self.trimesh = TriMesh((self.simplices, self.nodes))
self.trimesh_weighted = TriMesh((self.simplices, self.nodes),
vdims='weight')
def tearDown(self):
Store.current_backend = self.previous_backend
bokeh_renderer.comms['default'] = self.default_comm
def test_plot_simple_trimesh(self):
plot = bokeh_renderer.get_plot(self.trimesh)
node_source = plot.handles['scatter_1_source']
edge_source = plot.handles['multi_line_1_source']
layout_source = plot.handles['layout_source']
self.assertEqual(node_source.data['index'], np.arange(4))
self.assertEqual(edge_source.data['start'], np.arange(2))
self.assertEqual(edge_source.data['end'], np.arange(1, 3))
layout = {
str(int(z)): (x, y)
for x, y, z in self.trimesh.nodes.array()
}
self.assertEqual(layout_source.graph_layout, layout)
def test_plot_simple_trimesh_filled(self):
plot = bokeh_renderer.get_plot(
self.trimesh.opts(plot=dict(filled=True)))
node_source = plot.handles['scatter_1_source']
edge_source = plot.handles['patches_1_source']
layout_source = plot.handles['layout_source']
self.assertIsInstance(plot.handles['patches_1_glyph'], Patches)
self.assertEqual(node_source.data['index'], np.arange(4))
self.assertEqual(edge_source.data['start'], np.arange(2))
self.assertEqual(edge_source.data['end'], np.arange(1, 3))
layout = {
str(int(z)): (x, y)
for x, y, z in self.trimesh.nodes.array()
}
self.assertEqual(layout_source.graph_layout, layout)
def test_graph_edges_categorical_colormapped(self):
g = self.trimesh.opts(plot=dict(edge_color_index='node1'),
style=dict(edge_cmap=['#FFFFFF', '#000000']))
plot = bokeh_renderer.get_plot(g)
cmapper = plot.handles['edge_colormapper']
edge_source = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertIsInstance(cmapper, CategoricalColorMapper)
factors = ['0', '1', '2', '3']
self.assertEqual(cmapper.factors, factors)
self.assertEqual(edge_source.data['node1_str'], ['0', '1'])
self.assertEqual(glyph.line_color, {
'field': 'node1_str',
'transform': cmapper
})
def test_graph_nodes_numerically_colormapped(self):
g = self.trimesh_weighted.opts(
plot=dict(edge_color_index='weight'),
style=dict(edge_cmap=['#FFFFFF', '#000000']))
plot = bokeh_renderer.get_plot(g)
cmapper = plot.handles['edge_colormapper']
edge_source = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertIsInstance(cmapper, LinearColorMapper)
self.assertEqual(cmapper.low, 0)
self.assertEqual(cmapper.high, 1)
self.assertEqual(edge_source.data['weight'], np.array([0, 1]))
self.assertEqual(glyph.line_color, {
'field': 'weight',
'transform': cmapper
})
class TestMplTriMeshPlot(TestMPLPlot):
def setUp(self):
super(TestMplTriMeshPlot, self).setUp()
self.nodes = [(0, 0, 0), (0.5, 1, 1), (1., 0, 2), (1.5, 1, 3)]
self.simplices = [(0, 1, 2, 0), (1, 2, 3, 1)]
self.trimesh = TriMesh((self.simplices, self.nodes))
self.trimesh_weighted = TriMesh((self.simplices, self.nodes), vdims='weight')
def test_plot_simple_trimesh(self):
plot = mpl_renderer.get_plot(self.trimesh)
nodes = plot.handles['nodes']
edges = plot.handles['edges']
self.assertIsInstance(edges, LineCollection)
self.assertEqual(nodes.get_offsets(), self.trimesh.nodes.array([0, 1]))
self.assertEqual([p.vertices for p in edges.get_paths()],
[p.array() for p in self.trimesh._split_edgepaths.split()])
def test_plot_simple_trimesh_filled(self):
plot = mpl_renderer.get_plot(self.trimesh.opts(plot=dict(filled=True)))
nodes = plot.handles['nodes']
edges = plot.handles['edges']
self.assertIsInstance(edges, PolyCollection)
self.assertEqual(nodes.get_offsets(), self.trimesh.nodes.array([0, 1]))
paths = self.trimesh._split_edgepaths.split(datatype='array')
self.assertEqual([p.vertices[:4] for p in edges.get_paths()],
paths)
def test_plot_trimesh_colored_edges(self):
opts = dict(plot=dict(edge_color_index='weight'), style=dict(edge_cmap='Greys'))
plot = mpl_renderer.get_plot(self.trimesh_weighted.opts(**opts))
edges = plot.handles['edges']
colors = np.array([[ 1., 1., 1., 1.],
[ 0., 0., 0., 1.]])
self.assertEqual(edges.get_edgecolors(), colors)
def test_plot_trimesh_categorically_colored_edges(self):
opts = dict(plot=dict(edge_color_index='node1'), style=dict(edge_color=Cycle('Set1')))
plot = mpl_renderer.get_plot(self.trimesh_weighted.opts(**opts))
edges = plot.handles['edges']
colors = np.array([[0.894118, 0.101961, 0.109804, 1.],
[0.215686, 0.494118, 0.721569, 1.]])
self.assertEqual(edges.get_edgecolors(), colors)
def test_plot_trimesh_categorically_colored_edges_filled(self):
opts = dict(plot=dict(edge_color_index='node1', filled=True),
style=dict(edge_color=Cycle('Set1')))
plot = mpl_renderer.get_plot(self.trimesh_weighted.opts(**opts))
edges = plot.handles['edges']
colors = np.array([[0.894118, 0.101961, 0.109804, 1.],
[0.215686, 0.494118, 0.721569, 1.]])
self.assertEqual(edges.get_facecolors(), colors)
###########################
# Styling mapping #
###########################
def test_trimesh_op_node_color(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 'red'), (0, 0, 1, 'green'), (0, 1, 2, 'blue'), (1, 0, 3, 'black')]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_facecolors(),
np.array([[1, 0, 0, 1], [0, 0.501961, 0, 1], [0, 0, 1, 1], [0, 0, 0, 1]]))
def test_trimesh_op_node_color_linear(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 2), (0, 0, 1, 1), (0, 1, 2, 3), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_array(), np.array([2, 1, 3, 4]))
self.assertEqual(artist.get_clim(), (1, 4))
def test_trimesh_op_node_color_categorical(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 'B'), (0, 0, 1, 'C'), (0, 1, 2, 'A'), (1, 0, 3, 'B')]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_array(), np.array([0, 1, 2, 0]))
self.assertEqual(artist.get_clim(), (0, 2))
def test_trimesh_op_node_size(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 3), (0, 0, 1, 2), (0, 1, 2, 8), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='size'))).options(node_size='size')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_sizes(), np.array([9, 4, 64, 16]))
def test_trimesh_op_node_alpha(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 0.2), (0, 0, 1, 0.6), (0, 1, 2, 1), (1, 0, 3, 0.3)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='alpha'))).options(node_alpha='alpha')
with self.assertRaises(Exception):
mpl_renderer.get_plot(trimesh)
def test_trimesh_op_node_line_width(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 0.2), (0, 0, 1, 0.6), (0, 1, 2, 1), (1, 0, 3, 0.3)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='line_width'))).options(node_linewidth='line_width')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_linewidths(), [0.2, 0.6, 1, 0.3])
def test_trimesh_op_edge_color_linear_mean_node(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 2), (0, 0, 1, 1), (0, 1, 2, 3), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_array(), np.array([2, 8/3.]))
self.assertEqual(artist.get_clim(), (1, 4))
def test_trimesh_op_edge_color(self):
edges = [(0, 1, 2, 'red'), (1, 2, 3, 'blue')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_edgecolors(), np.array([
[1, 0, 0, 1], [0, 0, 1, 1]]))
def test_trimesh_op_edge_color_linear(self):
edges = [(0, 1, 2, 2.4), (1, 2, 3, 3.6)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_array(), np.array([2.4, 3.6]))
self.assertEqual(artist.get_clim(), (2.4, 3.6))
def test_trimesh_op_edge_color_categorical(self):
edges = [(0, 1, 2, 'A'), (1, 2, 3, 'B')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_array(), np.array([0, 1]))
self.assertEqual(artist.get_clim(), (0, 1))
def test_trimesh_op_edge_alpha(self):
edges = [(0, 1, 2, 0.7), (1, 2, 3, 0.3)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='alpha').options(edge_alpha='alpha')
with self.assertRaises(Exception):
mpl_renderer.get_plot(trimesh)
def test_trimesh_op_edge_line_width(self):
edges = [(0, 1, 2, 7), (1, 2, 3, 3)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='line_width').options(edge_linewidth='line_width')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_linewidths(), [7, 3])
class TestBokehTriMeshPlot(TestBokehPlot):
def setUp(self):
super(TestBokehTriMeshPlot, self).setUp()
self.nodes = [(0, 0, 0), (0.5, 1, 1), (1., 0, 2), (1.5, 1, 3)]
self.simplices = [(0, 1, 2, 0), (1, 2, 3, 1)]
self.trimesh = TriMesh((self.simplices, self.nodes))
self.trimesh_weighted = TriMesh((self.simplices, self.nodes), vdims='weight')
def test_plot_simple_trimesh(self):
plot = bokeh_renderer.get_plot(self.trimesh)
node_source = plot.handles['scatter_1_source']
edge_source = plot.handles['multi_line_1_source']
layout_source = plot.handles['layout_source']
self.assertEqual(node_source.data['index'], np.arange(4))
self.assertEqual(edge_source.data['start'], np.arange(2))
self.assertEqual(edge_source.data['end'], np.arange(1, 3))
layout = {str(int(z)): (x, y) for x, y, z in self.trimesh.nodes.array()}
self.assertEqual(layout_source.graph_layout, layout)
def test_plot_simple_trimesh_filled(self):
plot = bokeh_renderer.get_plot(self.trimesh.opts(plot=dict(filled=True)))
node_source = plot.handles['scatter_1_source']
edge_source = plot.handles['patches_1_source']
layout_source = plot.handles['layout_source']
self.assertIsInstance(plot.handles['patches_1_glyph'], Patches)
self.assertEqual(node_source.data['index'], np.arange(4))
self.assertEqual(edge_source.data['start'], np.arange(2))
self.assertEqual(edge_source.data['end'], np.arange(1, 3))
layout = {str(int(z)): (x, y) for x, y, z in self.trimesh.nodes.array()}
self.assertEqual(layout_source.graph_layout, layout)
def test_trimesh_edges_categorical_colormapped(self):
g = self.trimesh.opts(plot=dict(edge_color_index='node1'),
style=dict(edge_cmap=['#FFFFFF', '#000000']))
plot = bokeh_renderer.get_plot(g)
print(plot.handles)
cmapper = plot.handles['edge_colormapper']
edge_source = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertIsInstance(cmapper, CategoricalColorMapper)
factors = ['0', '1', '2', '3']
self.assertEqual(cmapper.factors, factors)
self.assertEqual(edge_source.data['node1_str__'], ['0', '1'])
self.assertEqual(glyph.line_color, {'field': 'node1_str__', 'transform': cmapper})
def test_trimesh_nodes_numerically_colormapped(self):
g = self.trimesh_weighted.opts(plot=dict(edge_color_index='weight'),
style=dict(edge_cmap=['#FFFFFF', '#000000']))
plot = bokeh_renderer.get_plot(g)
cmapper = plot.handles['edge_colormapper']
edge_source = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertIsInstance(cmapper, LinearColorMapper)
self.assertEqual(cmapper.low, 0)
self.assertEqual(cmapper.high, 1)
self.assertEqual(edge_source.data['weight'], np.array([0, 1]))
self.assertEqual(glyph.line_color, {'field': 'weight', 'transform': cmapper})
###########################
# Styling mapping #
###########################
def test_trimesh_op_node_color(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 'red'), (0, 0, 1, 'green'), (0, 1, 2, 'blue'), (1, 0, 3, 'black')]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
self.assertEqual(glyph.fill_color, {'field': 'node_color'})
self.assertEqual(glyph.line_color, 'black')
self.assertEqual(cds.data['node_color'], np.array(['red', 'green', 'blue', 'black']))
def test_trimesh_op_node_color_linear(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 2), (0, 0, 1, 1), (0, 1, 2, 3), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
cmapper = plot.handles['node_color_color_mapper']
self.assertEqual(glyph.fill_color, {'field': 'node_color', 'transform': cmapper})
self.assertEqual(glyph.line_color, 'black')
self.assertEqual(cds.data['node_color'], np.array([2, 1, 3, 4]))
self.assertEqual(cmapper.low, 1)
self.assertEqual(cmapper.high, 4)
def test_trimesh_op_node_color_categorical(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 'B'), (0, 0, 1, 'C'), (0, 1, 2, 'A'), (1, 0, 3, 'B')]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
cmapper = plot.handles['node_color_color_mapper']
self.assertEqual(glyph.fill_color, {'field': 'node_color', 'transform': cmapper})
self.assertEqual(glyph.line_color, 'black')
self.assertEqual(cds.data['node_color'], np.array(['B', 'C', 'A', 'B']))
def test_trimesh_op_node_size(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 3), (0, 0, 1, 2), (0, 1, 2, 8), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='size'))).options(node_size='size')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
self.assertEqual(glyph.size, {'field': 'node_size'})
self.assertEqual(cds.data['node_size'], np.array([3, 2, 8, 4]))
def test_trimesh_op_node_alpha(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 0.2), (0, 0, 1, 0.6), (0, 1, 2, 1), (1, 0, 3, 0.3)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='alpha'))).options(node_alpha='alpha')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
self.assertEqual(glyph.fill_alpha, {'field': 'node_alpha'})
self.assertEqual(glyph.line_alpha, {'field': 'node_alpha'})
self.assertEqual(cds.data['node_alpha'], np.array([0.2, 0.6, 1, 0.3]))
def test_trimesh_op_node_line_width(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 0.2), (0, 0, 1, 0.6), (0, 1, 2, 1), (1, 0, 3, 0.3)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='line_width'))).options(node_line_width='line_width')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['scatter_1_source']
glyph = plot.handles['scatter_1_glyph']
self.assertEqual(glyph.line_width, {'field': 'node_line_width'})
self.assertEqual(cds.data['node_line_width'], np.array([0.2, 0.6, 1, 0.3]))
def test_trimesh_op_edge_color_linear_mean_node(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 2), (0, 0, 1, 1), (0, 1, 2, 3), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(edge_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
cmapper = plot.handles['edge_color_color_mapper']
self.assertEqual(glyph.line_color, {'field': 'edge_color', 'transform': cmapper})
self.assertEqual(cds.data['edge_color'], np.array([2, 8/3.]))
self.assertEqual(cmapper.low, 1)
self.assertEqual(cmapper.high, 4)
def test_trimesh_op_edge_color(self):
edges = [(0, 1, 2, 'red'), (1, 2, 3, 'blue')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertEqual(glyph.line_color, {'field': 'edge_color'})
self.assertEqual(cds.data['edge_color'], np.array(['red', 'blue']))
def test_trimesh_op_edge_color_linear(self):
edges = [(0, 1, 2, 2.4), (1, 2, 3, 3.6)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
cmapper = plot.handles['edge_color_color_mapper']
self.assertEqual(glyph.line_color, {'field': 'edge_color', 'transform': cmapper})
self.assertEqual(cds.data['edge_color'], np.array([2.4, 3.6]))
self.assertEqual(cmapper.low, 2.4)
self.assertEqual(cmapper.high, 3.6)
def test_trimesh_op_edge_color_linear_filled(self):
edges = [(0, 1, 2, 2.4), (1, 2, 3, 3.6)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color', filled=True)
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['patches_1_source']
glyph = plot.handles['patches_1_glyph']
cmapper = plot.handles['edge_color_color_mapper']
self.assertEqual(glyph.fill_color, {'field': 'edge_color', 'transform': cmapper})
self.assertEqual(glyph.line_color, 'black')
self.assertEqual(cds.data['edge_color'], np.array([2.4, 3.6]))
self.assertEqual(cmapper.low, 2.4)
self.assertEqual(cmapper.high, 3.6)
def test_trimesh_op_edge_color_categorical(self):
edges = [(0, 1, 2, 'A'), (1, 2, 3, 'B')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
cmapper = plot.handles['edge_color_color_mapper']
self.assertEqual(glyph.line_color, {'field': 'edge_color', 'transform': cmapper})
self.assertEqual(cds.data['edge_color'], np.array(['A', 'B']))
self.assertEqual(cmapper.factors, ['A', 'B'])
def test_trimesh_op_edge_alpha(self):
edges = [(0, 1, 2, 0.7), (1, 2, 3, 0.3)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='alpha').options(edge_alpha='alpha')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertEqual(glyph.line_alpha, {'field': 'edge_alpha'})
self.assertEqual(cds.data['edge_alpha'], np.array([0.7, 0.3]))
def test_trimesh_op_edge_line_width(self):
edges = [(0, 1, 2, 7), (1, 2, 3, 3)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='line_width').options(edge_line_width='line_width')
plot = bokeh_renderer.get_plot(trimesh)
cds = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertEqual(glyph.line_width, {'field': 'edge_line_width'})
self.assertEqual(cds.data['edge_line_width'], np.array([7, 3]))
class TestBokehTriMeshPlot(TestBokehPlot):
def setUp(self):
super(TestBokehTriMeshPlot, self).setUp()
self.nodes = [(0, 0, 0), (0.5, 1, 1), (1., 0, 2), (1.5, 1, 3)]
self.simplices = [(0, 1, 2, 0), (1, 2, 3, 1)]
self.trimesh = TriMesh((self.simplices, self.nodes))
self.trimesh_weighted = TriMesh((self.simplices, self.nodes),
vdims='weight')
def test_plot_simple_trimesh(self):
plot = bokeh_renderer.get_plot(self.trimesh)
node_source = plot.handles['scatter_1_source']
edge_source = plot.handles['multi_line_1_source']
layout_source = plot.handles['layout_source']
self.assertEqual(node_source.data['index'], np.arange(4))
self.assertEqual(edge_source.data['start'], np.arange(2))
self.assertEqual(edge_source.data['end'], np.arange(1, 3))
layout = {
str(int(z)): (x, y)
for x, y, z in self.trimesh.nodes.array()
}
self.assertEqual(layout_source.graph_layout, layout)
def test_plot_simple_trimesh_filled(self):
plot = bokeh_renderer.get_plot(
self.trimesh.opts(plot=dict(filled=True)))
node_source = plot.handles['scatter_1_source']
edge_source = plot.handles['patches_1_source']
layout_source = plot.handles['layout_source']
self.assertIsInstance(plot.handles['patches_1_glyph'], Patches)
self.assertEqual(node_source.data['index'], np.arange(4))
self.assertEqual(edge_source.data['start'], np.arange(2))
self.assertEqual(edge_source.data['end'], np.arange(1, 3))
layout = {
str(int(z)): (x, y)
for x, y, z in self.trimesh.nodes.array()
}
self.assertEqual(layout_source.graph_layout, layout)
def test_graph_edges_categorical_colormapped(self):
g = self.trimesh.opts(plot=dict(edge_color_index='node1'),
style=dict(edge_cmap=['#FFFFFF', '#000000']))
plot = bokeh_renderer.get_plot(g)
cmapper = plot.handles['edge_colormapper']
edge_source = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertIsInstance(cmapper, CategoricalColorMapper)
factors = ['0', '1', '2', '3']
self.assertEqual(cmapper.factors, factors)
self.assertEqual(edge_source.data['node1_str'], ['0', '1'])
self.assertEqual(glyph.line_color, {
'field': 'node1_str',
'transform': cmapper
})
def test_graph_nodes_numerically_colormapped(self):
g = self.trimesh_weighted.opts(
plot=dict(edge_color_index='weight'),
style=dict(edge_cmap=['#FFFFFF', '#000000']))
plot = bokeh_renderer.get_plot(g)
cmapper = plot.handles['edge_colormapper']
edge_source = plot.handles['multi_line_1_source']
glyph = plot.handles['multi_line_1_glyph']
self.assertIsInstance(cmapper, LinearColorMapper)
self.assertEqual(cmapper.low, 0)
self.assertEqual(cmapper.high, 1)
self.assertEqual(edge_source.data['weight'], np.array([0, 1]))
self.assertEqual(glyph.line_color, {
'field': 'weight',
'transform': cmapper
})
class TestMplTriMeshPlot(TestMPLPlot):
def setUp(self):
super(TestMplTriMeshPlot, self).setUp()
self.nodes = [(0, 0, 0), (0.5, 1, 1), (1., 0, 2), (1.5, 1, 3)]
self.simplices = [(0, 1, 2, 0), (1, 2, 3, 1)]
self.trimesh = TriMesh((self.simplices, self.nodes))
self.trimesh_weighted = TriMesh((self.simplices, self.nodes), vdims='weight')
def test_plot_simple_trimesh(self):
plot = mpl_renderer.get_plot(self.trimesh)
nodes = plot.handles['nodes']
edges = plot.handles['edges']
self.assertIsInstance(edges, LineCollection)
self.assertEqual(np.asarray(nodes.get_offsets()), self.trimesh.nodes.array([0, 1]))
self.assertEqual([p.vertices for p in edges.get_paths()],
[p.array() for p in self.trimesh._split_edgepaths.split()])
def test_plot_simple_trimesh_filled(self):
plot = mpl_renderer.get_plot(self.trimesh.opts(plot=dict(filled=True)))
nodes = plot.handles['nodes']
edges = plot.handles['edges']
self.assertIsInstance(edges, PolyCollection)
self.assertEqual(np.asarray(nodes.get_offsets()), self.trimesh.nodes.array([0, 1]))
paths = self.trimesh._split_edgepaths.split(datatype='array')
self.assertEqual([p.vertices[:4] for p in edges.get_paths()],
paths)
def test_plot_trimesh_colored_edges(self):
opts = dict(plot=dict(edge_color_index='weight'), style=dict(edge_cmap='Greys'))
plot = mpl_renderer.get_plot(self.trimesh_weighted.opts(**opts))
edges = plot.handles['edges']
colors = np.array([[ 1., 1., 1., 1.],
[ 0., 0., 0., 1.]])
self.assertEqual(edges.get_edgecolors(), colors)
def test_plot_trimesh_categorically_colored_edges(self):
opts = dict(plot=dict(edge_color_index='node1'), style=dict(edge_color=Cycle('Set1')))
plot = mpl_renderer.get_plot(self.trimesh_weighted.opts(**opts))
edges = plot.handles['edges']
colors = np.array([[0.894118, 0.101961, 0.109804, 1.],
[0.215686, 0.494118, 0.721569, 1.]])
self.assertEqual(edges.get_edgecolors(), colors)
def test_plot_trimesh_categorically_colored_edges_filled(self):
opts = dict(plot=dict(edge_color_index='node1', filled=True),
style=dict(edge_color=Cycle('Set1')))
plot = mpl_renderer.get_plot(self.trimesh_weighted.opts(**opts))
edges = plot.handles['edges']
colors = np.array([[0.894118, 0.101961, 0.109804, 1.],
[0.215686, 0.494118, 0.721569, 1.]])
self.assertEqual(edges.get_facecolors(), colors)
###########################
# Styling mapping #
###########################
def test_trimesh_op_node_color(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 'red'), (0, 0, 1, 'green'), (0, 1, 2, 'blue'), (1, 0, 3, 'black')]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_facecolors(),
np.array([[1, 0, 0, 1], [0, 0.501961, 0, 1], [0, 0, 1, 1], [0, 0, 0, 1]]))
def test_trimesh_op_node_color_linear(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 2), (0, 0, 1, 1), (0, 1, 2, 3), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(np.asarray(artist.get_array()), np.array([2, 1, 3, 4]))
self.assertEqual(artist.get_clim(), (1, 4))
def test_trimesh_op_node_color_categorical(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 'B'), (0, 0, 1, 'C'), (0, 1, 2, 'A'), (1, 0, 3, 'B')]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(node_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(np.asarray(artist.get_array()), np.array([0, 1, 2, 0]))
self.assertEqual(artist.get_clim(), (0, 2))
def test_trimesh_op_node_size(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 3), (0, 0, 1, 2), (0, 1, 2, 8), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='size'))).options(node_size='size')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_sizes(), np.array([9, 4, 64, 16]))
def test_trimesh_op_node_alpha(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 0.2), (0, 0, 1, 0.6), (0, 1, 2, 1), (1, 0, 3, 0.3)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='alpha'))).options(node_alpha='alpha')
with self.assertRaises(Exception):
mpl_renderer.get_plot(trimesh)
def test_trimesh_op_node_line_width(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 0.2), (0, 0, 1, 0.6), (0, 1, 2, 1), (1, 0, 3, 0.3)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='line_width'))).options(node_linewidth='line_width')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['nodes']
self.assertEqual(artist.get_linewidths(), [0.2, 0.6, 1, 0.3])
def test_trimesh_op_edge_color_linear_mean_node(self):
edges = [(0, 1, 2), (1, 2, 3)]
nodes = [(-1, -1, 0, 2), (0, 0, 1, 1), (0, 1, 2, 3), (1, 0, 3, 4)]
trimesh = TriMesh((edges, Nodes(nodes, vdims='color'))).options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_array(), np.array([2, 8/3.]))
self.assertEqual(artist.get_clim(), (1, 4))
def test_trimesh_op_edge_color(self):
edges = [(0, 1, 2, 'red'), (1, 2, 3, 'blue')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_edgecolors(), np.array([
[1, 0, 0, 1], [0, 0, 1, 1]]))
def test_trimesh_op_edge_color_linear(self):
edges = [(0, 1, 2, 2.4), (1, 2, 3, 3.6)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_array(), np.array([2.4, 3.6]))
self.assertEqual(artist.get_clim(), (2.4, 3.6))
def test_trimesh_op_edge_color_categorical(self):
edges = [(0, 1, 2, 'A'), (1, 2, 3, 'B')]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='color').options(edge_color='color')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_array(), np.array([0, 1]))
self.assertEqual(artist.get_clim(), (0, 1))
def test_trimesh_op_edge_alpha(self):
edges = [(0, 1, 2, 0.7), (1, 2, 3, 0.3)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='alpha').options(edge_alpha='alpha')
with self.assertRaises(Exception):
mpl_renderer.get_plot(trimesh)
def test_trimesh_op_edge_line_width(self):
edges = [(0, 1, 2, 7), (1, 2, 3, 3)]
nodes = [(-1, -1, 0), (0, 0, 1), (0, 1, 2), (1, 0, 3)]
trimesh = TriMesh((edges, nodes), vdims='line_width').options(edge_linewidth='line_width')
plot = mpl_renderer.get_plot(trimesh)
artist = plot.handles['edges']
self.assertEqual(artist.get_linewidths(), [7, 3])
