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)