def _link_polys(self):
style = dict(editable=True)
plot = dict(width=self.table_width, height=self.table_height)
# Add annotation columns to poly data
for col in self.poly_columns:
if col not in self.polys:
self.polys = self.polys.add_dimension(col, 0, '', True)
self.poly_stream.source = self.polys
self.vertex_stream.source = self.polys
self._poly_selection.source = self.polys
if len(self.polys):
poly_data = gv.project(self.polys).split()
self.poly_stream.event(
data={
kd.name: [p.dimension_values(kd) for p in poly_data]
for kd in self.polys.kdims
})
poly_data = {
c: self.polys.dimension_values(c, expanded=False)
for c in self.poly_columns
}
if len(set(len(v) for v in poly_data.values())) != 1:
raise ValueError('poly_columns must refer to value dimensions '
'which vary per path while at least one of '
'%s varies by vertex.' % self.poly_columns)
self.poly_table = Table(poly_data, self.poly_columns,
[]).opts(plot=plot, style=style)
self.poly_link = DataLink(source=self.polys, target=self.poly_table)
self.vertex_table = Table([], self.polys.kdims,
self.vertex_columns).opts(plot=plot,
style=style)
self.vertex_link = VertexTableLink(self.polys, self.vertex_table)
def table(self):
"""
Return an ndmapping of the loaded data using the filenames as
values and the remaining data as the keys.
"""
all_dimension_labels = self.constant_keys + self.varying_keys
dimension_labels = [d for d in all_dimension_labels if d != self.key]
if dimension_labels == []:
return Table([spec[self.key] for spec in self.specs],
value_dimensions=[self.key])
table = Table(key_dimensions=dimension_labels,
value_dimensions=[self.key])
keys = []
for spec in self.specs:
value = spec[self.key]
key = tuple([spec[k] for k in dimension_labels])
if key in keys:
key_fmt = ', '.join('%s=%r' % (k, v)
for (k, v) in zip(dimension_labels, key))
self.warning('Key clash got %s (overriding)' % key_fmt)
table[key] = value
keys.append(key)
return table
def test_table_index_row_age(self):
table = Table(zip(self.keys1, self.values1),
kdims=self.key_dims1,
vdims=self.val_dims1)
row = table[:, 12]
self.assertEquals(type(row), Table)
self.assertEquals(row.data, OrderedDict([(('F', 12), (10, 0.8))]))
def test_table_index_row_gender(self):
table = Table(zip(self.keys1, self.values1),
key_dimensions=self.key_dims1,
value_dimensions=self.val_dims1)
row = table['F', :]
self.assertEquals(type(row), Table)
self.assertEquals(row.data, OrderedDict([(('F', 12), (10, 0.8))]))
def test_table_index_item_table(self):
table = Table(zip(self.keys1, self.values1),
kdims=self.key_dims1,
vdims=self.val_dims1)
itemtable = table['F', 12]
self.assertEquals(type(itemtable), ItemTable)
self.assertEquals(itemtable.data,
OrderedDict([('Weight', 10), ('Height', 0.8)]))
def test_table_index_rows_gender(self):
table = Table(zip(self.keys1, self.values1),
kdims=self.key_dims1,
vdims=self.val_dims1)
row = table['M', :]
self.assertEquals(type(row), Table)
self.assertEquals(
row.data,
OrderedDict([(('M', 10), (15, 0.8)), (('M', 16), (18, 0.6))]))
def __init__(self, **params):
super(PointAnnotator, self).__init__(**params)
style = dict(editable=True)
plot = dict(width=self.width, height=self.table_height)
for col in self.point_columns:
if col not in self.points:
self.points = self.points.add_dimension(col, 0, None, True)
self.point_stream = PointDraw(source=self.points, data={})
self.point_table = Table(self.points).opts(plot=plot, style=style)
def to_table(args, vdims=[]):
"Helper function to convet an Args object to a HoloViews Table"
if not Table:
return "HoloViews Table not available"
kdims = [
dim for dim in args.constant_keys + args.varying_keys
if dim not in vdims
]
items = [tuple([spec[k] for k in kdims + vdims]) for spec in args.specs]
return Table(items, kdims=kdims, vdims=vdims)
def __init__(self, poly_data={}, **params):
super(PolyAnnotator, self).__init__(**params)
style = dict(editable=True)
plot = dict(width=self.width, height=self.table_height)
self.polys.data = poly_to_geopandas(self.polys, self.poly_columns)
self.polys.interface = GeoPandasInterface
if len(self.polys):
poly_data = gv.project(self.polys).split()
self.poly_stream.event(
data={
kd.name: [p.dimension_values(kd) for p in poly_data]
for kd in self.polys.kdims
})
self.poly_table = Table(self.polys.data, self.poly_columns,
[]).opts(plot=plot, style=style)
self.vertex_table = Table([], self.polys.kdims,
self.vertex_columns).opts(plot=plot,
style=style)
self.vertex_link = VertexTableLink(self.polys, self.vertex_table)
def test_sample_coords(self):
arr = np.arange(10)*np.arange(5)[np.newaxis].T
xs = np.linspace(0.12, 0.81, 10)
ys = np.linspace(0.12, 0.391, 5)
img = Image((xs, ys, arr), kdims=['x', 'y'], vdims=['z'], datatype=[self.datatype])
sampled = img.sample([(0.15, 0.15), (0.15, 0.4), (0.8, 0.4), (0.8, 0.15)])
self.assertIsInstance(sampled, Table)
yidx = [0, 4, 4, 0]
xidx = [0, 0, 9, 9]
table = Table((xs[xidx], ys[yidx], arr[yidx, xidx]), kdims=['x', 'y'], vdims=['z'])
self.assertEqual(sampled, table)
def _link_points(self):
style = dict(editable=True)
plot = dict(width=self.table_width, height=self.table_height)
for col in self.point_columns:
if col not in self.points:
self.points = self.points.add_dimension(col, 0, None, True)
self.point_stream = PointDraw(source=self.points, data={})
projected = gv.project(self.points, projection=ccrs.PlateCarree())
self.point_table = Table(projected).opts(plot=plot, style=style)
self.point_link = PointTableLink(source=self.points,
target=self.point_table)
def load_table(self, table):
"""
Load the file contents into the supplied Table using the
specified key and filetype. The input table should have the
filenames as values which will be replaced by the loaded
data. If data_key is specified, this key will be used to index
the loaded data to retrive the specified item.
"""
items, data_keys = [], None
for key, filename in table.items():
data_dict = self.filetype.data(filename[0])
current_keys = tuple(sorted(data_dict.keys()))
values = [data_dict[k] for k in current_keys]
if data_keys is None:
data_keys = current_keys
elif data_keys != current_keys:
raise Exception("Data keys are inconsistent")
items.append((key, values))
return Table(items, kdims=table.kdims, vdims=data_keys)
def test_get_size_tables_in_layout(self):
table = Table(range(10), kdims=['x'])
plot = self.renderer.get_plot(table + table)
w, h = self.renderer.get_size(plot)
self.assertEqual((w, h), (680, 300))
def table(self):
if not Table:
return "HoloViews Table not available"
keys = self.varying_keys + self.constant_keys
items = [(tuple([spec[k] for k in keys]), ()) for spec in self.specs]
return Table(items, key_dimensions=keys, value_dimensions=[])
def test_get_size_table(self):
table = Table(range(10), kdims=['x'])
plot = self.renderer.get_plot(table)
w, h = self.renderer.get_size(plot)
self.assertEqual((w, h), (288, 288))
def test_table_index_value1(self):
table = Table(zip(self.keys1, self.values1),
key_dimensions=self.key_dims1,
value_dimensions=self.val_dims1)
self.assertEquals(table['F', 12, 'Weight'], 10)
def test_table_init(self):
self.table1 = Table(zip(self.keys1, self.values1),
kdims=self.key_dims1,
vdims=self.val_dims1)
def group_table(self):
plot = dict(width=self.table_width, height=self.table_height)
data = [(group, str(inds)) for group, inds in self._group_data.items()]
return Table(data, self.column, 'index').sort().opts(plot=plot)
def view(self):
if self.Screen1 == "radial":
set_screen1("radial", sid)
populate_radial_diagram(df, sid, datashaded=self.datashaded)
if self.Screen1 == "force":
set_screen1("force", sid)
populate_force_diagram(df, sid, datashaded=self.datashaded)
if self.Screen1 == "hierarchical":
set_screen1("hierarchical", sid)
populate_hierarchical_diagram(df, sid, datashaded=self.datashaded)
if self.Screen1 == "3d":
set_screen1("3d", sid)
populate_3d_diagram(df, sid)
# print(s1[1])
screen1 = get_custom_key(get_screen1(sid), sid)
if self.Screen1 == "3d":
zero_zero = Column(get_custom_key(get_screen1(sid), sid), css_classes=['screen-1', 'col-s-6'])
else:
screen1.color_palette = self.Color_palette
screen1.node_size = self.Node_size
screen1.node_color = self.Node_color
set_custom_key(get_screen1(sid), screen1, sid)
if self.Screen2 == "matrix":
set_screen2("matrix", sid)
populate_matrix(get_matrix_df(sid), sid)
screen2 = get_custom_key(get_screen2(sid), sid)
screen2.reordering = self.Ordering
screen2.metric = self.Metric
screen2.color_palette = self.Color_palette
set_custom_key(get_screen2(sid), screen2, sid)
matrix = screen2.view()
edge_table = Table(matrix.data).opts(height=int(get_window_height(sid)/3), width=290)
SelectedDataLink(matrix, edge_table)
zero_one = Column(matrix, css_classes=['screen-2', 'col-s-6'])
if self.Screen1 != "3d":
# Setting up the linking, generateDiagram functions return two-tuple (graph, points). Points is the selection layer
# makeMatrix returns matrix_dropdown object. matrix.view returns the heatmap object
SelectMatrixToNodeLink.register_callback('bokeh', SelectMatrixToNodeCallback)
SelectNodeToMatrixLink.register_callback('bokeh', SelectNodeToMatrixCallback)
SelectNodeToTableLink.register_callback('bokeh', SelectNodeToTableCallback)
graph, points = screen1.view()
node_table = Table(points.data[['index', 'indegree', 'outdegree']]).opts(height=int(get_window_height(sid)/3), width=290)
# Link matrix to the nodelink (both graph and points)
SelectMatrixToNodeLink(matrix, points)
SelectNodeToTableLink(points, node_table)
# Link nodelink to matrix (points only)
SelectNodeToMatrixLink(points, matrix)
# For highlighting edges when tapping on node, but doesn't work
# if not self.datashaded:
# PointToGraphLink.register_callback('bokeh', PointToGraphCallback)
# PointToGraphLink(points, graph)
zero_zero = Column(graph * points, css_classes=['screen-1', 'col-s-6'])
if not self.Ran:
zero_two = Row(Column(node_table, css_classes=['node-table', 'invisible']),
Column(edge_table, css_classes=['edge-table', 'invisible']),
css_classes=['trash'])
else:
if not self.Ran:
zero_two = Row(Column(edge_table, css_classes=['edge-table', 'invisible']),
css_classes=['trash'])
# SelectedDataLink(matrix, points)
# renderer = renderer('bokeh')
# print(renderer.get_plot(points).handles)
if not self.Ran:
self.Ran = True
return Row(zero_zero, zero_one, zero_two, css_classes=['good-width'])
return Row(zero_zero, zero_one, css_classes=['good-width'])
def test_table_index_value2(self):
table = Table(zip(self.keys1, self.values1),
kdims=self.key_dims1,
vdims=self.val_dims1)
self.assertEquals(table['F', 12, 'Height'], 0.8)