def drawGraph(self): graph = self.graph N = len(graph.vertices) node_indices = list(graph.vertices) plot = figure(title="Graph Layout Demonstration", x_range=(-1.1, 10.1), y_range=(-1.1, 10.1), tools='', toolbar_location=None) graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add(node_indices, 'index') graph_renderer.node_renderer.data_source.add( [graph.vertices[vertex_id].color for vertex_id in graph.vertices], 'color') graph_renderer.node_renderer.glyph = Circle(radius=0.5, fill_color='color') start_indices = [] end_indices = [] for vertex_id in graph.vertices: #here we're looking at the keys of our vertex dictionary for edge_end in graph.vertices[vertex_id].edges: start_indices.append(vertex_id) end_indices.append(edge_end) graph_renderer.edge_renderer.data_source.data = dict( start=start_indices, end=end_indices) ### start of layout code x = [graph.vertices[vertex_id].x for vertex_id in graph.vertices] y = [graph.vertices[vertex_id].y for vertex_id in graph.vertices] graph_layout = dict(zip(node_indices, zip(x, y))) graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) plot.renderers.append(graph_renderer) labelSource = ColumnDataSource( data=dict(x=x, y=y, names=[ graph.vertices[vertex_id].value for vertex_id in graph.vertices ])) labels = LabelSet(x='x', y='y', text='names', level='glyph', text_align='center', text_baseline='middle', source=labelSource, render_mode='canvas') plot.add_layout(labels) output_file('graph1.html') show(plot) # class BokehGraph: # """Class that takes a graph and exposes drawing methods.""" # def __init__(self, graph): # self.graph = graph # def drawGraph(self): # pass # #test # graph1 = Graph() # Instantiate your graph # graph1.add_vertex(0) # graph1.add_vertex(1) # graph1.add_vertex(2) # graph1.add_vertex(3) # graph1.add_edge(0, 1) # graph1.add_edge(0, 3) # bokehGraph1 = BokehGraph(graph1) # bokehGraph1.drawGraph() # ###### Bookeh example for Visualizing Network Graphs (https://bokeh.pydata.org/en/latest/docs/user_guide/graph.html) ########## # import math # from bokeh.io import show, output_file # from bokeh.plotting import figure # # "Bokeh uses a separate LayoutProvider model in order to supply the coordinates of a graph in Cartesian space. Currently the only built-in provider is the StaticLayoutProvider model, which contains a dictionary of (x,y) coordinates for the nodes."" # from bokeh.models import GraphRenderer, StaticLayoutProvider, Oval # from bokeh.palettes import Spectral8 # N = 8 # node_indices = list(range(N)) # # figure class (imported above) creates a new Figure for plotting. class Figure(*ark, **kw) is a subclass of Plot that simplifies plot creation with default axes, grids, tools, etc. # plot = figure(title='Graph Layout Demonstration', x_range=(-1.1,1.1), y_range=(-1.1,1.1), # tools='', toolbar_location=None) # # GraphRenderer class: maintains separate sub-GlyphRenderers for the graph nodes and the graph edges. This allows for customizing the nodes by modifying the GraphRenderer’s node_renderer property. # # -edge_renderer attribute: Instance of GlyphRenderer class containing an MultiLine Glyph that will be rendered as the graph edges. # # -node_renderer attribute: Instance of GlyphRenderer class containing an XYGlyph (point-like Glyph) that will be rendered as the graph nodes. # graph = GraphRenderer() # # data_source attribute of Glyphrenderer: Local data source to use when rendering glyphs on the plot. Instance of the DataSource class. The DataSource class is a an abstract base class used to help organize the hierarchy of Bokeh model types. It is not useful to instantiate on its own. # # Two requirements for data sources belonging to node_renderer and edge_renderer # # -The ColumnDataSource (i.e. a JSON dict that maps names to arrays of values) associated with the node sub-renderer must have a column named "index" that contains the unique indices of the nodes. # # -The ColumnDataSource associated with the edge sub-renderer has two required columns: "start" and "end". These columns contain the node indices of for the start and end of the edges. # # ColumnDataSource is a bokeh class that maps names of columns to sequences or arrays. It's a fundamental data structure of Bokeh. Most plots, data tables, etc. will be driven by a ColumnDataSource. # graph.node_renderer.data_source.add(node_indices, 'index') # # spectral8 (a color palette) specifies the range of colors used for the plot markers # graph.node_renderer.data_source.add(Spectral8, 'color') # # specifies the shape and style of the plot markers (i.e. graph nodes in our case) # # GlyphRenderer class attr glyph: Instance of Glyph class. Specifies glyph to render, in conjunction with the supplied data source and ranges. # graph.node_renderer.glyph = Oval(height=0.1, width=0.2, fill_color='color') # # The ColumnDataSource associated with the edge sub-renderer has two required columns: "start" and "end". These columns contain the node indices of for the start and end of the edges. # # data attribute of ColumnDataSource class : Mapping of column names to sequences of data. The data can be, e.g, Python lists or tuples, NumPy arrays, etc. # graph.edge_renderer.data_source.data = dict( # start=[0]*N, # end=node_indices) # ### start of layout code # # circ here is a list populated with the different angles of a circle (i.e. 0 to 2*pi) # circ = [i*2*math.pi/8 for i in node_indices] # x = [math.cos(i) for i in circ] # y = [math.sin(i) for i in circ] # # the zip() method: The purpose of zip() is to map the similar index of multiple containers so that they can be used just using as single entity. # graph_layout = dict(zip(node_indices, zip(x, y))) # # StaticLayoutProvider base class: bokeh.models.graphs.LayoutProvider (abstract data type. not useful on its own.) # # graph_layout attribute of StaticLayoutProvider: The coordinates of the graph nodes in cartesian space. The dictionary keys correspond to a node index and the values are a two element sequence containing the x and y coordinates of the node. (property type: Dict ( Either ( String , Int ), Seq ( Any ) )) # # By default the StaticLayoutProvider will draw straight-line paths between the supplied node positions. In order to supply explicit edge paths you may also supply lists of paths to the edge_renderer bokeh.models.sources.ColumnDataSource. The StaticLayoutProvider will look for these paths on the "xs" and "ys" columns of the data source. Note that these paths should be in the same order as the "start" and "end" points. # graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) # # plot here is an instantiation of the Figure class (A subclass of Plot that simplifies plot creation with default axes, grids, tools, etc.) # # renderers is an attribute of Plot. Description:A list of all renderers for this plot, including guides and annotations in addition to glyphs and markers. property type: List ( Instance ( Renderer ) ). Recall that Renderer is an abstract base class used to help organize the hierarchy of Bokeh model types. It is not useful to instantiate on its own. # plot.renderers.append(graph) # # output_file(): Configures the default output state to generate output saved to a file when show() is called. (https://bokeh.pydata.org/en/latest/docs/reference/io.html#bokeh.io.output_file) # output_file('graphEx1.html') # # show(): Immediately displays a Bokeh object or application. (https://bokeh.pydata.org/en/latest/docs/reference/io.html#bokeh.io.show) # show(plot) # ############## Attempt 1 ######################## # # NOTE: I didn't finish this first attempt at the BokehGraph class. In interest of time # # I decided to pause and implement the solution code from graph lecture day 2. # class BokehGraph: # """Class that takes a graph and exposes drawing methods.""" # def __init__(self, graph): # self.graph = graph # def drawGraph(self): # graph = self.graph # N = len(graph.vertices) # node_indices = list() # for i in graph.vertices: # node_indices.append(i.value) # # figure class (imported above) creates a new Figure for plotting. class Figure(*ark, **kw) is a subclass of Plot that simplifies plot creation with default axes, grids, tools, etc. # plot = figure(title = 'Adrian\'s Graph Demo', x_range = (-10,10), y_range = (-10,10)) # # GraphRenderer class: maintains separate sub-GlyphRenderers for the graph nodes and the graph edges. This allows for customizing the nodes by modifying the GraphRenderer’s node_renderer property. # # -edge_renderer attribute: Instance of GlyphRenderer class containing an MultiLine Glyph that will be rendered as the graph edges. # # -node_renderer attribute: Instance of GlyphRenderer class containing an XYGlyph (point-like Glyph) that will be rendered as the graph nodes. # graphRenderer = GraphRenderer() # # data_source attribute of Glyphrenderer: Local data source to use when rendering glyphs on the plot. Instance of the DataSource class. The DataSource class is a an abstract base class used to help organize the hierarchy of Bokeh model types. It is not useful to instantiate on its own. # # Two requirements for data sources belonging to node_renderer and edge_renderer # # -The ColumnDataSource (i.e. a JSON dict that maps names to arrays of values) associated with the node sub-renderer must have a column named "index" that contains the unique indices of the nodes. # # -The ColumnDataSource associated with the edge sub-renderer has two required columns: "start" and "end". These columns contain the node indices of for the start and end of the edges. # # ColumnDataSource is a bokeh class that maps names of columns to sequences or arrays. It's a fundamental data structure of Bokeh. Most plots, data tables, etc. will be driven by a ColumnDataSource. # graphRenderer.node_renderer.data_source.add(node_indices, 'index') # # # spectral8 (a color palette) specifies the range of colors used for the plot markers # # graphRenderer.node_renderer.data_source.add(Spectral8, 'color') # # specifies the shape and style of the plot markers (i.e. graph nodes in our case) # # GlyphRenderer class attr glyph: Instance of Glyph class. Specifies glyph to render, in conjunction with the supplied data source and ranges. # graphRenderer.node_renderer.glyph = Circle(radius=0.2) # # The ColumnDataSource associated with the edge sub-renderer has two required columns: "start" and "end". These columns contain the node indices of for the start and end of the edges. # # data attribute of ColumnDataSource class : Mapping of column names to sequences of data. The data can be, e.g, Python lists or tuples, NumPy arrays, etc. # start_indices = [] # end_indices = [] # for vertex in graph.vertices: # for edge_end in graph.vertices[vertex].adjVertices: # start_indices.append(vertex.value) # end_indices.append(edge_end.value) # # print(start_indices) # # print(end_indices) # # print(start_indices) # # print(end_indices) # graphRenderer.edge_renderer.data_source.data = dict( # start=start_indices, # end=end_indices) # ### start of layout code # x = [graph.vertices[vertex].x for vertex in graph.vertices] # y = [graph.vertices[vertex].y for vertex in graph.vertices] # x = [] # y = [] # for vertex in graph.vertices: # x.append(vertex.x) # y.append(vertex.y) # # the zip() method: The purpose of zip() is to map the similar index of multiple containers so that they can be used just using as single entity. # graph_layout = dict(zip(node_indices, zip(x, y))) # # StaticLayoutProvider base class: bokeh.models.graphs.LayoutProvider (abstract data type. not useful on its own.) # # graph_layout attribute of StaticLayoutProvider: The coordinates of the graph nodes in cartesian space. The dictionary keys correspond to a node index and the values are a two element sequence containing the x and y coordinates of the node. (property type: Dict ( Either ( String , Int ), Seq ( Any ) )) # # By default the StaticLayoutProvider will draw straight-line paths between the supplied node positions. In order to supply explicit edge paths you may also supply lists of paths to the edge_renderer bokeh.models.sources.ColumnDataSource. The StaticLayoutProvider will look for these paths on the "xs" and "ys" columns of the data source. Note that these paths should be in the same order as the "start" and "end" points. # graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) # plot.renderers.append(graphRenderer) # output_file('graphEx1.html') # show(plot)
end_indices.append(edge_end) print(start_indices) print(end_indices) graph_renderer.edge_renderer.data_source.data = dict(start=start_indices, end=end_indices) # start of layout code grid = [int(v) for v in graph.vertices] x = [2 * (i // 3) for i in grid] y = [2 * (i % 3) for i in grid] # x = [i for i in grid] # y = [i ** 2 for i in grid] graph_layout = dict(zip(node_indices, zip(x, y))) graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) plot.renderers.append(graph_renderer) labelSource = ColumnDataSource(data=dict(x=x, y=y, names=grid)) labels = LabelSet(x='x', y='y', text='names', level='glyph', text_align='center', text_baseline='middle', source=labelSource, render_mode='canvas') plot.add_layout(labels)
def draw(self): graph = self.graph N = len(graph.vertices) node_indices = list(graph.vertices.keys()) plot = figure(title="Graph Layout Demonstration", x_range=(-6, 6), y_range=(-6, 6), tools="", toolbar_location=None) graph_render = GraphRenderer() graph_render.node_renderer.data_source.add(node_indices, 'index') node_colors = [] for vert in graph.vertices: node_colors.append(graph.vertices[vert].color) # node_colors = ['red'] * int(N / 2) # another_color = ['blue'] * int(N/2) # node_colors.extend(another_color) # if N % 2 != 0: # node_colors.extend(['green']) graph_render.node_renderer.data_source.add(node_colors, 'color') graph_render.node_renderer.glyph = Circle(radius=0.25, fill_color="color") edge_start = [] edge_end = [] for vert_id in node_indices: for v in graph.vertices[vert_id].edges: edge_start.append(vert_id) edge_end.append(v) graph_render.edge_renderer.data_source.data = dict(start=edge_start, end=edge_end) ### start of layout code # circ = [i*2*math.pi/8 for i in node_indices] # x = [math.cos(i) for i in circ] # y = [math.sin(i) for i in circ] x = [] y = [] for vert_id in node_indices: vertex = graph.vertices[vert_id] x.append(vertex.x) y.append(vertex.y) graph_layout = dict(zip(node_indices, zip(x, y))) graph_render.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) plot.renderers.append(graph_render) labelSource = ColumnDataSource( data=dict(x=x, y=y, names=[vert_id for vert_id in graph.vertices])) labels = LabelSet(x='x', y='y', text='names', level='glyph', text_align='center', text_baseline='middle', source=labelSource, render_mode='canvas') plot.add_layout(labels) output_file("graph_demo.html") # output_file("graph.html") show(plot) # graph = Graph() # Instantiate your graph # graph.add_vertex('0') # graph.add_vertex('1') # graph.add_vertex('2') # graph.add_vertex('3') # graph.add_vertex('4') # graph.add_edge('0', '1') # graph.add_edge('0', '3') # graph.add_edge('3', '4') # bg = BokehGraph(graph) # bg.draw()
def _init_glyphs(self, plot, element, ranges, source): # Get data and initialize data source style = self.style[self.cyclic_index] data, mapping, style = self.get_data(element, ranges, style) edge_mapping = { k: v for k, v in mapping[self.edge_glyph].items() if 'color' not in k } self.handles['previous_id'] = element._plot_id properties = {} mappings = {} for key in list(mapping): if not any(glyph in key for glyph in ('scatter_1', self.edge_glyph)): continue source = self._init_datasource(data.pop(key, {})) self.handles[key + '_source'] = source glyph_props = self._glyph_properties(plot, element, source, ranges, style) properties.update(glyph_props) mappings.update(mapping.pop(key, {})) properties = { p: v for p, v in properties.items() if p not in ('legend', 'source') } properties.update(mappings) layout = data.pop('layout', {}) if data and mapping: CompositeElementPlot._init_glyphs(self, plot, element, ranges, source, data, mapping, style) # Define static layout layout = StaticLayoutProvider(graph_layout=layout) node_source = self.handles['scatter_1_source'] edge_source = self.handles[self.edge_glyph + '_source'] renderer = plot.graph(node_source, edge_source, layout, **properties) # Initialize GraphRenderer if self.selection_policy == 'nodes': renderer.selection_policy = NodesAndLinkedEdges() elif self.selection_policy == 'edges': renderer.selection_policy = EdgesAndLinkedNodes() else: renderer.selection_policy = None if self.inspection_policy == 'nodes': renderer.inspection_policy = NodesAndLinkedEdges() elif self.inspection_policy == 'edges': renderer.inspection_policy = EdgesAndLinkedNodes() else: renderer.inspection_policy = None self.handles['layout_source'] = layout self.handles['glyph_renderer'] = renderer self.handles['scatter_1_glyph_renderer'] = renderer.node_renderer self.handles[self.edge_glyph + '_glyph_renderer'] = renderer.edge_renderer self.handles['scatter_1_glyph'] = renderer.node_renderer.glyph if self.filled or self.bezier: glyph_model = Patches if self.filled else Bezier allowed_properties = glyph_model.properties() for glyph_type in ('', 'selection_', 'nonselection_', 'hover_', 'muted_'): glyph = getattr(renderer.edge_renderer, glyph_type + 'glyph', None) if glyph is None: continue props = self._process_properties(self.edge_glyph, properties, mappings) filtered = self._filter_properties(props, glyph_type, allowed_properties) new_glyph = glyph_model(**dict(filtered, **edge_mapping)) setattr(renderer.edge_renderer, glyph_type + 'glyph', new_glyph) self.handles[self.edge_glyph + '_glyph'] = renderer.edge_renderer.glyph if 'hover' in self.handles: self.handles['hover'].renderers.append(renderer)
def setup_labels(graph): label_source = ColumnDataSource(data=dict( # x=[pos['x'] for pos in get_positions()], # y=[pos['y'] for pos in get_positions()], x=x, y=y, values=get_values())) labels = LabelSet(x='x', y='y', text='values', level='overlay', text_align='center', text_baseline='middle', source=label_source, render_mode='canvas') return labels graph_layout = dict(zip(node_indices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) plot.renderers.append(graph) plot.add_layout(setup_labels(graph)) output_file('graph.html') show(plot)
def draw(self): graph = self.graph N = len(graph.vertices) node_indices = list(graph.vertices.keys()) plot = figure(title="Graph Layout Demonstration", x_range=(-7, 7), y_range=(-7, 7), tools="", toolbar_location=None) graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add(node_indices, 'index') # node_colors = ['red'] * N # graph.node_renderer.data_source.add(node_colors, 'color') graph_renderer.node_renderer.glyph = Circle(radius=0.5, line_width=5, line_color="yellow", fill_color="red") edge_start = [] edge_end = [] # O(E), where E is the total number of edges for vertex_id in node_indices: for v in graph.vertices[vertex_id].edges: edge_start.append(vertex_id) edge_end.append(v) graph_renderer.edge_renderer.data_source.data = dict(start=edge_start, end=edge_end) ### start of layout code # circ = [i*2*math.pi/8 for i in node_indices] # x = [math.cos(i) for i in circ] # y = [math.sin(i) for i in circ] x = [] y = [] for vertex_id in node_indices: vertex = graph.vertices[vertex_id] x.append(vertex.x) y.append(vertex.y) graph_layout = dict(zip(node_indices, zip(x, y))) graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) plot.renderers.append(graph_renderer) labelSource = ColumnDataSource(data=dict( x=x, y=y, names=[vertex_id for vertex_id in graph.vertices])) labels = LabelSet(x='x', y='y', text='names', level='glyph', text_align='center', text_baseline='middle', text_color="white", source=labelSource, render_mode='canvas') plot.add_layout(labels) output_file('graph.html') show(plot)
network.edge_renderer.data_source.data = dict(start=[1]*total_nodes, end=node_points) #Render your network in 2-D space node_circumference = [node*2*math.pi/10 for node in node_points] x = [math.cos(circum) for circum in node_circumference] y = [math.sin(circum) for circum in node_circumference] network_layout = dict(zip(node_points, zip(x, y))) #Output the network network.layout_provider = StaticLayoutProvider(graph_layout=network_layout) plot.renderers.append(network) output_file('network.html') show(plot) --------------------------------------------------------------------------------------------------------- #Network with explicit paths #Import the required packages import math from bokeh.io import show, output_file
def show_flow_from_outside_to_buffers_to_tasks(self): from bokeh.io import output_file, show from bokeh.models import GraphRenderer, Oval, StaticLayoutProvider, ColumnDataSource, LabelSet, Arrow, OpenHead from bokeh.plotting import figure from bokeh.palettes import Plasma256 # vector alpha >0 , vector a can be any value # a is input/output coming from outside # alpha is initial value in buffer # matrix G connected buffers and tasks # in matrix G , flow between a task and multiple buffers # a to buffer to task number_of_io_nodes = len(self.a) number_of_buffers = self.K number_of_tasks = len(self.H[0]) index_array_of_io = list(range(1, number_of_io_nodes + 1)) index_array_of_buffers = list( range(number_of_io_nodes + 1, number_of_io_nodes + number_of_buffers + 1)) index_array_of_tasks = list( range(number_of_io_nodes + number_of_buffers + 1, number_of_io_nodes + number_of_buffers + number_of_tasks + 1)) node_indices = np.concatenate( (index_array_of_io, index_array_of_buffers, index_array_of_tasks), axis=None).tolist() node_x_location = np.concatenate( (index_array_of_io, list(range(1, len(index_array_of_buffers) + 1)), list(range(1, len(index_array_of_tasks) + 1))), axis=None).tolist() node_y_location = np.concatenate( (np.full(number_of_io_nodes, 7), np.full( number_of_buffers, 5), np.full(number_of_tasks, 3)), axis=None).tolist() max_x_range = max(number_of_io_nodes, number_of_buffers, number_of_tasks) + 1 plot = figure(title='Flow from outside to buffers to tasks', x_range=(0, max_x_range), y_range=(0, 9), tools='', toolbar_location=None) graph = GraphRenderer() graph.node_renderer.data_source.add(node_indices, 'index') graph.node_renderer.data_source.add(Plasma256[:len(node_indices)], 'color') graph.node_renderer.glyph = Oval(height=0, width=0, fill_color='color') start = index_array_of_io end = index_array_of_buffers network_graph_buffer_task_hash = {} for buffer_index in range(number_of_buffers): network_graph_buffer_task_hash[buffer_index + 1] = np.sum( self.G[buffer_index, :]) graph.edge_renderer.data_source.data = dict(start=start, end=end) x = node_x_location y = node_y_location graph_layout = dict(zip(node_indices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) plot.renderers.append(graph) x_io = list(range(1, number_of_io_nodes + 1)) y_io = np.full(number_of_io_nodes, 7) plot.triangle(x_io, y_io, size=30, color=getLargePalette(number_of_io_nodes, Plasma256), alpha=0.5, line_width=2) x_buffers = list(range(1, number_of_buffers + 1)) y_buffers = np.full(number_of_buffers, 5) plot.rect(x_buffers, y_buffers, color=getLargePalette(number_of_buffers, Plasma256), alpha=0.5, width=0.5, height=0.5) x_tasks = list(range(1, number_of_tasks + 1)) y_tasks = np.full(number_of_tasks, 3) plot.circle(x_tasks, y_tasks, size=30, color=getLargePalette(number_of_tasks, Plasma256), alpha=0.5) for i in range(number_of_buffers): for j in range(number_of_tasks): if self.G[i, j] > 0: x_start_node = x_buffers[i] y_start_node = y_buffers[i] x_end_node = x_tasks[j] y_end_node = y_tasks[j] elif self.G[i, j] < 0: x_start_node = x_tasks[j] y_start_node = y_tasks[j] x_end_node = x_buffers[i] y_end_node = y_buffers[i] plot.add_layout( Arrow(end=OpenHead(), x_start=x_start_node, y_start=y_start_node, x_end=x_end_node, y_end=y_end_node)) text_label_values = np.round( np.multiply( np.round(list(network_graph_buffer_task_hash.values()), 2), 100)).tolist() text_label_values = [ str(int(capacity)) + '%' for capacity in text_label_values ] source = ColumnDataSource( data=dict(x=list(network_graph_buffer_task_hash.keys()), y=np.full(number_of_buffers, 4.8), values=text_label_values)) capacityLabels = LabelSet(x='x', y='y', text='values', level='glyph', x_offset=-8, y_offset=10, source=source, render_mode='canvas', text_font_size="10pt") plot.add_layout(capacityLabels) source = ColumnDataSource( data=dict(x=[ max_x_range / 2 - 0.5, max_x_range / 2 - 0.5, max_x_range / 2 - 0.5 ], y=[2.5, 5.5, 7.5], values=['tasks', 'buffers', 'outside sources'])) typeLabel = LabelSet(x='x', y='y', text='values', level='glyph', x_offset=0, y_offset=0, source=source, render_mode='canvas', text_font_size="10pt") plot.add_layout(typeLabel) output_file('graph.html') show(plot) return None
def player_plot(): plot = figure(plot_height=500, plot_width=800, tools="save,tap", x_range=[0, 100], y_range=[0, 100], toolbar_location="below") plot.image_url(url=["myapp/static/images/base.png"], x=0, y=0, w=100, h=100, anchor="bottom_left") lower = np.round(range_slider.value[0]) higher = np.round(range_slider.value[1]) filter_data = final_data[(final_data['Game_Time_Start'] >= lower) & (final_data['Game_Time_Start'] <= higher)] size = filter_data.groupby(['From', 'To']).size().reset_index(name="Freq") grouped = filter_data.groupby(['To'])[['Start_x', 'Start_y']].mean().reset_index() G = nx.DiGraph() for index, row in grouped.iterrows(): G.add_node(row['To'], pos=row[['Start_x', 'Start_y']]) for index, row in size.iterrows(): G.add_edge(row['From'], row['To'], weight=row['Freq']) fixed_pos = grouped.set_index('To').T.to_dict('list') fixed_nodes = fixed_pos.keys() pos = nx.get_node_attributes(G, 'pos') edges = G.edges() weights = [G[u][v]['weight'] for u, v in edges] graph = from_networkx(G, nx.spring_layout) fixed_layout_provider = StaticLayoutProvider(graph_layout=pos) graph.layout_provider = fixed_layout_provider graph.node_renderer.glyph = Circle(size=20, fill_color='orangered') plot.xgrid.grid_line_color = None plot.ygrid.grid_line_color = None plot.axis.visible = False graph.edge_renderer.data_source.data["line_width"] = [ G.get_edge_data(a, b)['weight'] for a, b in G.edges() ] graph.edge_renderer.glyph.line_width = {'field': 'line_width'} plot.renderers.append(graph) pos_values = np.array(fixed_pos.values()) coordinates = pd.DataFrame(pos_values, columns=['x', 'y']) coordinates['player'] = fixed_pos.keys() source = ColumnDataSource( data=dict(x=coordinates.x, y=coordinates.y, player=coordinates.player)) labels = LabelSet(x='x', y='y', text='player', source=source, x_offset=-45, y_offset=-25, text_color='black', render_mode='canvas', text_font_size='10pt') plot.renderers.append(labels) return plot
def draw(self): myGraph = self.graph N = len(myGraph.vertices) # node_indices = list(myGraph.vertices.keys()) plot = figure(title="Graph Layout Demonstration", x_range=(-7, 7), y_range=(-7, 7), tools="", toolbar_location=None) graph = GraphRenderer() print("BFT", myGraph.BFT(myGraph.vertices[0].id)) connected = myGraph.connected_components() node_indices = connected print("NI", node_indices) # graph.node_renderer.data_source.add(range(N), 'index') graph.node_renderer.data_source.add( [vertex for vertex in list(self.graph.vertices.keys())], 'index') hex_keys = [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' ] # print(random_color) component_colors = [] for v in myGraph.vertices: # print(myGraph.vertices[v].color) component_colors.append(f"#{''.join(sample(hex_keys, 6))}") # myGraph.vertices[v].color = component_colors[myGraph.vertices[v].component] vertex_colors = [] for vertex in myGraph.vertices: vertex_colors.append( component_colors[myGraph.vertices[vertex].component]) print(vertex_colors) graph.node_renderer.data_source.add(vertex_colors, 'color') graph.node_renderer.glyph = Circle(radius=0.5, fill_color='color') edge_start = [] edge_end = [] for vertex_id in range(N): for v in myGraph.vertices[vertex_id].edges: edge_start.append(vertex_id) edge_end.append(v) graph.edge_renderer.data_source.data = dict(start=edge_start, end=edge_end) ### start of layout code # circ = [i*2*math.pi/8 for i in node_indices] # x = [math.cos(i) for i in circ] # y = [math.sin(i) for i in circ] x = [] y = [] for vertex_id in range(N): vertex = myGraph.vertices[vertex_id] x.append(vertex.x) y.append(vertex.y) graph_layout = dict(zip(range(N), zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) ### Draw quadratic bezier paths # def bezier(start, end, control, steps): # return [(1-s)**2*start + 2*(1-s)*s*control + s**2*end for s in steps] # xs, ys = [], [] # sx, sy = graph_layout[0] # steps = [i/100. for i in range(100)] # for node_index in node_indices: # ex, ey = graph_layout[node_index] # xs.append(bezier(sx, ex, 0, steps)) # ys.append(bezier(sy, ey, 0, steps)) # graph.edge_renderer.data_source.data['xs'] = xs # graph.edge_renderer.data_source.data['ys'] = ys plot.renderers.append(graph) labelSource = ColumnDataSource(data=dict( x=x, y=y, names=[vertex_id for vertex_id in myGraph.vertices])) labels = LabelSet(x='x', y='y', text='names', level='glyph', text_align='center', text_baseline='middle', source=labelSource, render_mode='canvas') plot.add_layout(labels) output_file("graph.html") show(plot) # graph = Graph() # graph.add_vertex(0) # graph.add_vertex(1) # graph.add_vertex(2) # graph.add_vertex(3) # graph.add_edge(0, 1) # graph.add_edge(0, 3) # bokehGraph = BokehGraph(graph) # bokehGraph.draw()
def show_task_capacity_per_server(self): from bokeh.io import output_file, show from bokeh.models import GraphRenderer, Oval, StaticLayoutProvider, ColumnDataSource, LabelSet from bokeh.plotting import figure from bokeh.palettes import Category20c, Category20 # we have 12 kinds of tasks (number of columns in H) and 4 time_slots (number of rows in H) number_of_servers = len(self.H) tasks = ['task ' + str(i) for i in range(1, len(self.H[0]) + 1)] index_array_of_tasks = list(range(1, len(tasks) + 1)) index_array_of_servers = list( range(len(tasks) + 1, len(tasks) + number_of_servers + 1)) number_of_tasks = len(tasks) node_indices = np.concatenate( (index_array_of_tasks, index_array_of_servers), axis=None).tolist() node_x_location = np.concatenate( (index_array_of_tasks, list(range(1, len(index_array_of_servers) + 1))), axis=None).tolist() node_y_location = np.concatenate( (np.full(len(index_array_of_tasks), 5), np.full(len(index_array_of_servers), 3)), axis=None).tolist() plot = figure(title='Task capacity per server', x_range=(0, max(number_of_servers, number_of_tasks) + 1), y_range=(0, 8), tools='', toolbar_location=None) graph = GraphRenderer() graph.node_renderer.data_source.add(node_indices, 'index') graph.node_renderer.data_source.add(Category20c[len(node_indices)], 'color') graph.node_renderer.glyph = Oval(height=0, width=0, fill_color='color') network_graph_tasks_indices = [] network_graph_server_indices = [] network_graph_tasks_server_hash = {} for k in range(number_of_servers): # servers for j in range(number_of_tasks): # tasks if self.H[k, j] > 0: network_graph_tasks_indices.append(j + 1) network_graph_server_indices.append(len(tasks) + k + 1) network_graph_tasks_server_hash[j + 1] = self.H[k, j] graph.edge_renderer.data_source.data = dict( start=list(network_graph_tasks_indices), end=list(network_graph_server_indices)) x = node_x_location y = node_y_location graph_layout = dict(zip(node_indices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) plot.renderers.append(graph) x_servers = list(range(1, len(index_array_of_servers) + 1)) y_servers = np.full(len(index_array_of_servers), 3) plot.square(x_servers, y_servers, size=30, color=Category20[number_of_servers], alpha=0.5) x_tasks = index_array_of_tasks y_tasks = np.full(len(index_array_of_tasks), 5) plot.circle(x_tasks, y_tasks, size=30, color=Category20[len(index_array_of_tasks)], alpha=0.5) text_label_values = np.round( np.multiply( np.round(list(network_graph_tasks_server_hash.values()), 2), 100)).tolist() text_label_values = [ str(int(capacity)) + '%' for capacity in text_label_values ] source = ColumnDataSource( data=dict(x=list(network_graph_tasks_server_hash.keys()), y=np.full(len(network_graph_tasks_indices), 4.8), values=text_label_values)) capacityLabels = LabelSet(x='x', y='y', text='values', level='glyph', x_offset=-8, y_offset=10, source=source, render_mode='canvas', text_font_size="10pt") plot.add_layout(capacityLabels) source = ColumnDataSource( data=dict(x=[6, 6], y=[2.5, 5.5], values=['servers', 'tasks'])) typeLabel = LabelSet(x='x', y='y', text='values', level='glyph', x_offset=0, y_offset=0, source=source, render_mode='canvas', text_font_size="10pt") plot.add_layout(typeLabel) output_file('graph.html') show(plot) return None
def draw(self): graph = self.graph N = len(graph.vertices) node_indices = list(graph.vertices.keys()) plot = figure(title='Graph Layout Demonstration', x_range=(-7,7), y_range=(-7,7), tools='', toolbar_location=None) graph_renderer = GraphRenderer() edge_start = [] edge_end = [] for vertex in node_indices: for edge in graph.vertices[vertex].edges: edge_start.append(vertex) edge_end.append(edge) print('edge start', edge_start) print('edge end', edge_end) graph_renderer.edge_renderer.data_source.data = dict( start=edge_start, end=edge_end ) x = [] y = [] ### start of layout code for vertex_id in node_indices: vertex = graph.vertices[vertex_id] x.append(vertex.x) y.append(vertex.y) source = ColumnDataSource( data=dict( x = x, y = y, names = node_indices ) ) color_mapper = [''] * len(node_indices) for index, node in enumerate(node_indices): print('color mapper', color_mapper) for edge in edge_start: if node == edge: print('equals') color_mapper[index] = 'red' for index, color in enumerate(color_mapper): if color == '': color_mapper[index] = 'blue' graph_renderer.node_renderer.data_source.add(node_indices, 'index') graph_renderer.node_renderer.data_source.add(color_mapper, 'color') graph_renderer.node_renderer.glyph = Circle(radius=.40, fill_color='color') graph_renderer_layout = dict(zip(node_indices, zip(x, y))) graph_renderer.layout_provider = StaticLayoutProvider(graph_layout=graph_renderer_layout) labels= LabelSet( x = 'x', y = 'y', text='names', level='glyph', x_offset = -4, y_offset = -8, source = source, render_mode = 'canvas' ) plot.renderers.append(graph_renderer) plot.add_layout(labels) output_file('graph.html') show(plot)
def stream_update(x, vals): global f0 nsc = vals["nescience"] mis = vals["miscoding"] sur = vals["surfeit"] ina = vals["inaccuracy"] scr = vals["score"] source_nsc.stream(dict(x=[x], y=[nsc]), rollover=100) source_mis.stream(dict(x=[x], y=[mis]), rollover=100) source_sur.stream(dict(x=[x], y=[sur]), rollover=100) source_ina.stream(dict(x=[x], y=[ina]), rollover=100) source_scr.stream(dict(x=[x], y=[scr]), rollover=100) # Display neural network canvas_size = 1 top = .9 * canvas_size bottom = .1 * canvas_size left = .1 * canvas_size right = .9 * canvas_size layer_sizes = vals["layer_sizes"] N = np.sum(layer_sizes) v_spacing = (top - bottom)/float(max(layer_sizes)) h_spacing = (right - left)/float(len(layer_sizes) - 1) node_indices = list(range(N)) graph = GraphRenderer() graph.node_renderer.data_source.add(node_indices, 'index') size = int(v_spacing * 300) graph.node_renderer.glyph = Circle(size=size, fill_color='white') # Plot edges start = list() end = list() count = 0 for n, (layer_size_a, layer_size_b) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])): for m in np.arange(layer_size_a): for o in np.arange(layer_size_b): start.append(count + m) end.append(count + layer_size_a + o) count = count + layer_size_a graph.edge_renderer.data_source.data = dict(start=start, end=end) # Nodes x = list() y = list() for n, layer_size in enumerate(layer_sizes): layer_top = v_spacing * (layer_size - 1)/2. + (top + bottom)/2. for m in np.arange(layer_size): x.append(n * h_spacing + left) y.append(layer_top - m * v_spacing) graph_layout = dict(zip(node_indices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) if len(f0.renderers) != 0: f0.renderers.pop() f0.renderers.append(graph)
def draw(self): graph = self.graph cc = self.cc N = len(graph.vertices) n = len(cc) if self.connected == False: graph_colors = sample(Category20[20], N) else: colors_dict = {} colors = list(sample(Category20[20], n)) for arr in cc: color = colors.pop() for num in arr: colors_dict[num] = color graph_colors = [] for i in range(N): graph_colors.append(colors_dict[i]) print(f"\nConnected Components: {cc}") node_indices = list(graph.vertices.keys()) plot = figure(title="Bokeh Graph", x_range=(-12, 12), y_range=(-12, 12), tools="", toolbar_location=None) graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add(node_indices, 'index') graph_renderer.node_renderer.data_source.add(graph_colors, 'color') graph_renderer.node_renderer.glyph = Circle(radius=0.4, fill_color="color") edge_start = [] edge_end = [] for vertex_id in node_indices: for v in graph.vertices[vertex_id].edges: edge_start.append(vertex_id) edge_end.append(v) graph_renderer.edge_renderer.data_source.data = dict(start=edge_start, end=edge_end) ### start of layout code x = [] y = [] for vertex_id in node_indices: vertex = graph.vertices[vertex_id] x.append(vertex.x) y.append(vertex.y) graph_layout = dict(zip(node_indices, zip(x, y))) graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) plot.renderers.append(graph_renderer) labelSource = ColumnDataSource(data=dict( x=x, y=y, names=[vertex_id for vertex_id in graph.vertices])) labels = LabelSet(x='x', y='y', text='names', level='glyph', text_align='center', text_baseline='middle', source=labelSource, render_mode='canvas') plot.add_layout(labels) output_file('graph.html') show(plot)
def create_graph(): #Find the layout and color choice if radio_layout.active == 0: lay = 'WDegreepos' elif radio_layout.active == 1: lay = 'bwcentralpos' else: lay = 'ccentralpos' if radio_color.active == 0: col = 'DegCol' elif radio_color.active == 1: col = 'Colbw' elif radio_color.active == 2: col = 'friend' elif radio_color.active == 3: col = 'reviewcount' else: col = 'comprank' # Create Network view graph = GraphRenderer() graph.node_renderer.data_source.data = nodes_df(G, col) graph.edge_renderer.data_source.data = edges_df(G) graph.node_renderer.glyph = Circle(size='size', fill_color='Col', line_color="black", line_alpha = 0.1, fill_alpha=1) graph.edge_renderer.glyph = MultiLine(line_alpha='alpha', line_width=0.1, line_color="#d8b7a4") graph_layout = dict(nx.get_node_attributes(G, lay)) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) # Glyph properties on selection graph.selection_policy = NodesAndLinkedEdges() graph.inspection_policy = EdgesAndLinkedNodes() graph.node_renderer.selection_glyph = Circle(size=12, fill_color='#0A5EB6', line_color="#002217") graph.edge_renderer.selection_glyph = MultiLine(line_color="#2972BE", line_width=0.5, line_alpha=0.4) x = ['1','2','3','4','5'] y = [0,0,0,0,0] s2 = ColumnDataSource(data=dict(x=x, y=y)) hplot = figure(title="Rating by user", y_axis_label='% of Ratings Given', x_axis_label="Ratings", toolbar_location=None, tools="", x_range=['1','2','3','4','5'], y_range=(0, 50), plot_width=250, plot_height=250) hplot.vbar(x='x', top='y', source=s2, width=1, line_color="#ffffff") hplot.outline_line_alpha = 0 hplot.yaxis.axis_line_color = "#a7a7a7" hplot.yaxis.major_tick_line_color = "#a7a7a7" hplot.yaxis.minor_tick_line_color = None hplot.ygrid.grid_line_color = None hplot.xgrid.grid_line_color = None hplot.xaxis.axis_line_color = "#a7a7a7" hplot.xaxis.minor_tick_line_color = None hplot.xaxis.major_tick_line_color = "#a7a7a7" # callback = CustomJS(args=dict(source=graph.node_renderer.data_source), code = # """ # console.log(cb_obj) # var inds = cb_data.source.selected['1d'].indices # window.alert(inds) # """) true_source = ColumnDataSource(data=dict(x=[0,1,10,35,10,0,5,25,8,3,3,4,10,7,1])) callback = CustomJS(args=dict(s1=graph.node_renderer.data_source,s2=s2, ts=true_source), code= """ var inds = cb_data.source.selected['1d'].indices // .source is an on object of cb_data //window.alert(inds) var data = s2.data var tsdata = ts.data var ynew = tsdata['x'] data['y'] = [] if (inds<150){ for (var i = 0; i < 5; i++) { data['y'].push(ynew[i+5]) } } else if (inds <300){ for (var i = 0; i < 5; i++) { data['y'].push(ynew[i]) } } else { for (var i = 0; i < 5; i++) { data['y'].push(ynew[i+10]) } } s2.change.emit(); """) # Adding graph to plot plot = figure(title="Yelp Users Layout", x_range=(-6.5, 6.5), y_range=(-6.5, 6.5), plot_width=525, plot_height=525, toolbar_location="above") plot.outline_line_alpha = 0 plot.xgrid.grid_line_color = None plot.ygrid.grid_line_color = None plot.xaxis.visible = False plot.yaxis.visible = False plot.renderers.append(graph) # Adding graph plot.add_tools(TapTool(callback=callback)) return row(plot,hplot)
def show(self): graph = self.graph node_indices = list(self.graph.vertices) N = len(node_indices) # print(node_indices) plot = figure(title='Graph Layout Demonstration', x_range=(-1.1, 15.1), y_range=(-1.1, 15.1), tools='', toolbar_location=None) graph_renderer = GraphRenderer() colors = Viridis256[0:N] # print(colors) graph_renderer.node_renderer.data_source.add(node_indices, 'index') graph_renderer.node_renderer.data_source.add(colors, 'color') graph_renderer.node_renderer.glyph = Circle(radius=.2, fill_color='color') start_indices = [] end_indices = [] for vertex_id in graph.vertices: for edge_end in graph.vertices[vertex_id].edges: start_indices.append(vertex_id) end_indices.append(edge_end) graph_renderer.edge_renderer.data_source.data = dict( start=start_indices, end=end_indices) # start of layout code # circ = [int(v*2*math.pi/8) for v in self.graph.vertices] linear = [int(v * 2 * math.pi / 8) for v in self.graph.vertices] # x = [math.cos(i) for i in circ] # y = [math.sin(i) for i in circ] x = [graph.vertices[vertex_id].x for vertex_id in graph.vertices] y = [graph.vertices[vertex_id].y for vertex_id in graph.vertices] graph_layout = dict(zip(node_indices, zip(x, y))) graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) plot.renderers.append(graph_renderer) labelSource = ColumnDataSource( data=dict(x=x, y=y, names=[ graph.vertices[vertex_id].value for vertex_id in graph.vertices ])) labels = LabelSet(x='x', y='y', text='names', level='glyph', text_align='center', text_baseline='middle', source=labelSource, render_mode='canvas') plot.add_layout(labels) output_file('graph.html') show(plot) # graph = Graph() # bokeh = BokehGraph(graph) # bokeh.graph.add_vertex('0') # bokeh.graph.add_vertex('1') # bokeh.graph.add_vertex('2') # bokeh.graph.add_vertex('3') # bokeh.graph.add_edge('0', '1') # bokeh.graph.add_edge('0', '3') # bokeh.graph.add_edge('2', '3') # bokeh.graph.add_vertex('4') # bokeh.graph.add_edge('2', '4') # bokeh.graph.add_edge('4', '3') # bokeh.show()
def interactiveG(G): from bokeh.models.graphs import NodesAndLinkedEdges, from_networkx from bokeh.models import Circle, HoverTool, MultiLine, Plot, Range1d, StaticLayoutProvider from bokeh.plotting import figure, output_file, show, ColumnDataSource from bokeh.io import output_notebook, show output_notebook() # We could use figure here but don't want all the axes and titles #plot=Plot(plot_width=1600, plot_height=300, tooltips=TOOLTIPS,title="PHmi+landmarks+route+power(10,-5)",x_range=Range1d(-1.1,1.1), y_range=Range1d(-1.1,1.1)) output_file("PHMI_network") source = ColumnDataSource(data=dict( x=locations[0].tolist(), #x=[idx for idx in range(len(PHMIList))], #y=locations[1].tolist(), y=PHMIList, #desc=[str(i) for i in PHMIList], #PHMI_value=PHMI_dic[0][0].tolist(), )) TOOLTIPS = [ ("index", "$index"), ("(x,y)", "($x, $y)"), #("desc", "@desc"), #("PHMI", "$PHMI_value"), ] plot = figure(x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1), plot_width=2200, plot_height=500, tooltips=TOOLTIPS, title="PHMI_network") #G_position={key:(G.position[key][1],G.position[key][0]) for key in G.position.keys()} graph = from_networkx(G, nx.spring_layout, scale=1, center=(0, 0)) #plot.renderers.append(graph) fixed_layout_provider = StaticLayoutProvider(graph_layout=G.position) graph.layout_provider = fixed_layout_provider plot.renderers.append(graph) # Blue circles for nodes, and light grey lines for edges graph.node_renderer.glyph = Circle(size=5, fill_color='#2b83ba') graph.edge_renderer.glyph = MultiLine(line_color="#cccccc", line_alpha=0.8, line_width=2) # green hover for both nodes and edges graph.node_renderer.hover_glyph = Circle(size=25, fill_color='#abdda4') graph.edge_renderer.hover_glyph = MultiLine(line_color='#abdda4', line_width=4) # When we hover over nodes, highlight adjecent edges too graph.inspection_policy = NodesAndLinkedEdges() plot.add_tools(HoverTool(tooltips=None)) colors = ( 'aliceblue', 'antiquewhite', 'aqua', 'aquamarine', 'azure', 'beige', 'bisque', 'black', 'blanchedalmond', 'blue', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'fuchsia', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'gray', 'green', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'lime', 'limegreen', 'linen', 'magenta', 'maroon', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'navy', 'oldlace', 'olive', 'olivedrab', 'orange', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'purple', 'red', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'silver', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'teal', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'white', 'whitesmoke', 'yellow', 'yellowgreen') ScalePhmi = math.pow(10, 1) i = 0 for val, idx in zip(phmi_breakPtsNeg, plot_x): plot.line(idx, np.array(val) * ScalePhmi, line_color=colors[i]) i += 1 show(plot)
def generate_bokeh_graph(): N = 8 node_indices = list(range(N)) plot = figure(title="Graph Layout Demonstration", x_range=(-1.1, 1.1), y_range=(-1.1, 1.1), tools="", toolbar_location=None) graph = GraphRenderer() graph.node_renderer.data_source.add(node_indices, 'index') graph.node_renderer.data_source.add(Spectral8, 'color') graph.node_renderer.glyph = Oval(height=0.1, width=0.2, fill_color="color") graph.edge_renderer.data_source.data = dict(start=[0] * N, end=node_indices) ### start of layout code circ = [i * 2 * math.pi / 8 for i in node_indices] x = [math.cos(i) for i in circ] y = [math.sin(i) for i in circ] graph_layout = dict(zip(node_indices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) ### Draw quadratic bezier paths def bezier(start, end, control, steps): return [(1 - s)**2 * start + 2 * (1 - s) * s * control + s**2 * end for s in steps] xs, ys = [], [] sx, sy = graph_layout[0] steps = [i / 100. for i in range(100)] for node_index in node_indices: ex, ey = graph_layout[node_index] xs.append(bezier(sx, ex, 0, steps)) ys.append(bezier(sy, ey, 0, steps)) graph.edge_renderer.data_source.data['xs'] = xs graph.edge_renderer.data_source.data['ys'] = ys plot.renderers.append(graph) output_file("graph.html") show(plot) # generate_bokeh_graph() # # u = Digraph('digraph', file_path='digraph.gv', # node_attr={'color': 'lightblue2', 'style': 'filled'}) # u.attr(size='6,6') # # u.edge('5th Edition', '6th Edition', label='n') # u.edge('5th Edition', 'PWB 1.0',label='n') # u.edge('6th Edition', 'LSX',label='n') # u.edge('6th Edition', '1 BSD') # u.edge('6th Edition', 'Mini Unix') # u.edge('6th Edition', 'Wollongong') # u.edge('6th Edition', 'Interdata') # u.edge('Interdata', 'Unix/TS 3.0') # u.edge('Interdata', 'PWB 2.0') # u.edge('Interdata', '7th Edition') # u.edge('7th Edition', '8th Edition') # u.edge('7th Edition', '32V') # u.edge('7th Edition', 'V7M') # u.edge('7th Edition', 'Ultrix-11') # u.view() #https://stackoverflow.com/questions/51038073/flask-dynamic-graphviz-and-svg-example # You can use svg just like this: # # {{ chart_output|safe }} # and also, you can use png format: # # @app.route('/') # def svgtest(): # chart_data = Graph() # # chart_data.node('H', 'Hello') # chart_data.node('W', 'World') # chart_data.edge('H', 'W') # # # chart_output = chart_data.pipe(format='png') # chart_output = base64.b64encode(chart_output).decode('utf-8') # # return render_template('svgtest.html', chart_output=chart_output) # and the html like this: # # <img src="data:image/png;base64,{{chart_output|safe}}" />
def draw(self): graph = self.graph N = len(graph.vertices) node_indices = list(graph.vertices.keys()) plot = figure(title="Graph Demonstration", x_range=(-7, 7), y_range=(-7, 7), tools="", toolbar_location=None) graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add(node_indices, 'index') # node_colors = ['blue'] * N # graph_renderer.node_renderer.data_source.add(node_colors, 'color') graph_renderer.node_renderer.glyph = Circle(radius=0.5, fill_color='blue') edge_start = [] edge_end = [] for vertex_id in node_indices: for v in graph.vertices[vertex_id].edges: edge_start.append(vertex_id) edge_end.append(v) graph_renderer.edge_renderer.data_source.data = dict(start=edge_start, end=edge_end) ### start of layout code x = [] y = [] for vertex_id in node_indices: vertex = graph.vertices[vertex_id] x.append(vertex.x) y.append(vertex.y) graph_layout = dict(zip(node_indices, zip(x, y))) graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) plot.renderers.append(graph_renderer) labelSource = ColumnDataSource(data=dict( x=x, y=y, names=[vertex_id for vertex_id in graph.vertices])) labels = LabelSet(x='x', y='y', text='names', level='glyph', text_align='center', text_baseline='middle', source=labelSource, render_mode='canvas', text_color='white') plot.add_layout(labels) output_file('test_graph.html') show(plot)
def build_lay_out(graph_renderer, axis): graph_renderer.layout_provider = StaticLayoutProvider(graph_layout=axis) return graph_renderer
def make_figure(nodes, edges, correlation_edges, pos): # define gplot gplot = figure(title=None, x_range=(-2, 2), y_range=(-2, 2), tools="reset,save", plot_width=900, plot_height=900, match_aspect=False) graph = GraphRenderer() # add nodes light_node = Ellipse(height=RADIUS, width=RADIUS, fill_color="color", line_color="#000000", line_width=5) heavy_node = Ellipse(height=RADIUS, width=RADIUS, fill_color="color", line_color="#000000", line_width=7) for k in nodes: graph.node_renderer.data_source.add(nodes[k], k) graph.node_renderer.glyph = light_node graph.node_renderer.hover_glyph = heavy_node graph.node_renderer.selection_glyph = heavy_node graph.node_renderer.nonselection_glyph = light_node # add directed edges graph.edge_renderer.name = "edges" for k in correlation_edges: graph.edge_renderer.data_source.add(correlation_edges[k], k) light_edge = MultiLine(line_width="width", line_color="color", line_alpha="alpha") heavy_edge = MultiLine(line_width="width", line_color="color", line_alpha=1) graph.edge_renderer.glyph = light_edge graph.edge_renderer.hover_glyph = heavy_edge graph.edge_renderer.selection_glyph = light_edge graph.edge_renderer.nonselection_glyph = light_edge # arrows arrow = NormalHead(fill_color="#000000", line_color=None, size=8) arrow_source = ColumnDataSource(dict(x_start=[], y_start=[], x_end=[], y_end=[])) gplot.add_layout( Arrow( end=arrow, source=arrow_source, x_start="x_start", y_start="y_start", x_end="x_end", y_end="y_end" ) ) # add labels p_ind = np.linspace(0, 1-1/len(pos), len(pos)) * np.pi * 2 xr = 1.1 * np.cos(p_ind) yr = 1.1 * np.sin(p_ind) rad = np.arctan2(yr, xr) gplot.text(xr, yr, nodes["index"], angle=rad, text_font_size="9pt", text_align="left", text_baseline="middle") # render graph.layout_provider = StaticLayoutProvider(graph_layout=pos) graph.inspection_policy = EdgesAndLinkedNodes() graph.selection_policy = NodesAndLinkedEdges() # widgets edges_original = ColumnDataSource(edges) slider = Slider(start=0.0, end=1.0, value=0.0, step=0.1, title="absolute correlation coefficient is greater than") checkbox = CheckboxButtonGroup( labels=EDGE_LABELS, active=[0] ) callback = CustomJS( args=dict( graph=graph, edges_original=edges_original, arrow_source=arrow_source, checkbox=checkbox, slider=slider ), code=""" var e = graph.edge_renderer.data_source.data; var n = graph.node_renderer.data_source.data; var a = arrow_source.data; var o = edges_original.data; var cb = checkbox.active; var sv = slider.value; var ns = graph.node_renderer.data_source.selected.indices; if (ns.length > 0) { var nn = n['index'][ns[0]]; for (var key in o) { var vals = []; for (var i = 0; i < o['start'].length; ++i) { if ((o['start'][i] == nn || o['end'][i] == nn) && (Math.abs(o['r'][i]) > sv) && (cb.indexOf(o['type'][i]) > -1)) { vals.push(o[key][i]); } } e[key] = vals; } a['x_start'].length = 0; a['y_start'].length = 0; a['x_end'].length = 0; a['y_end'].length = 0; for (var i = 0; i < o['start'].length; ++i) { if ((o['start'][i] == nn || o['end'][i] == nn) && (Math.abs(o['r'][i]) > sv) && (cb.indexOf(o['type'][i]) > -1)) { if (o['e_arrow'][i] === 1) { var l = o['xs'][i].length; a['x_start'].push(o['xs'][i][l - 2]); a['y_start'].push(o['ys'][i][l - 2]); a['x_end'].push(o['xs'][i][l - 1]); a['y_end'].push(o['ys'][i][l - 1]); } if (o['b_arrow'][i] === 1) { a['x_start'].push(o['xs'][i][1]); a['y_start'].push(o['ys'][i][1]); a['x_end'].push(o['xs'][i][0]); a['y_end'].push(o['ys'][i][0]); } } } } else { for (var key in o) { var vals = []; for (var i = 0; i < o['start'].length; ++i) { if ((Math.abs(o['r'][i]) > sv) && (cb.indexOf(o['type'][i]) > -1)) { vals.push(o[key][i]); } } e[key] = vals; } a['x_start'].length = 0; a['y_start'].length = 0; a['x_end'].length = 0; a['y_end'].length = 0; for (var i = 0; i < o['start'].length; ++i) { if ((Math.abs(o['r'][i]) > sv) && (cb.indexOf(o['type'][i]) > -1)) { if (o['e_arrow'][i] === 1) { var l = o['xs'][i].length; a['x_start'].push(o['xs'][i][l - 2]); a['y_start'].push(o['ys'][i][l - 2]); a['x_end'].push(o['xs'][i][l - 1]); a['y_end'].push(o['ys'][i][l - 1]); } if (o['b_arrow'][i] === 1) { a['x_start'].push(o['xs'][i][1]); a['y_start'].push(o['ys'][i][1]); a['x_end'].push(o['xs'][i][0]); a['y_end'].push(o['ys'][i][0]); } } } } graph.edge_renderer.data_source.change.emit(); arrow_source.change.emit(); """) slider.js_on_change("value", callback) checkbox.js_on_change("active", callback) graph.node_renderer.data_source.selected.js_on_change("indices", callback) hover = HoverTool( tooltips=[ ("node", "@start"), ("node", "@end"), ("type", "@type_name"), ("pearson", "@r{0.3f}"), ("p-value", "@pval"), ], renderers=[graph] ) gplot.background_fill_color = BACKGROUND gplot.xgrid.grid_line_color = None gplot.ygrid.grid_line_color = None gplot.axis.visible = False gplot.add_tools(hover, TapTool()) gplot.toolbar.logo = None gplot.toolbar_location = None gplot.border_fill_color = None gplot.outline_line_color = None gplot.renderers.append(graph) return { "gplot": gplot, "widgets": widgetbox(slider, checkbox, width=450) }
def draw(self): graph = self.graph N = len(graph.vertices) node_indices = list(graph.vertices) plot = figure( title='Graph Layout Demonstration', x_range=(-1.1, 50), y_range=(-1.1, 5), # tools='', toolbar_location=None, plot_width=1450, plot_height=1000) graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add(node_indices, 'index') graph_renderer.node_renderer.data_source.add( [graph.vertices[vertex_id].color for vertex_id in graph.vertices], 'color') graph_renderer.node_renderer.glyph = Circle(radius=0.5, fill_color='color') start_indices = [] end_indices = [] for vertex_id in graph.vertices: for edge_end in graph.vertices[vertex_id].edges: start_indices.append(vertex_id) end_indices.append(edge_end) graph_renderer.edge_renderer.data_source.data = dict( start=start_indices, end=end_indices) ### start of layout code x = [graph.vertices[vertex_id].x for vertex_id in graph.vertices] y = [graph.vertices[vertex_id].y for vertex_id in graph.vertices] graph_layout = dict(zip(node_indices, zip(x, y))) graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) plot.renderers.append(graph_renderer) labelSource = ColumnDataSource( data=dict(x=x, y=y, names=[ graph.vertices[vertex_id].value for vertex_id in graph.vertices ])) labels = LabelSet(x='x', y='y', text='names', level='glyph', text_align='center', text_baseline='middle', source=labelSource, render_mode='canvas') plot.add_layout(labels) output_file('graph.html') show(plot)
def show(self): graph = self.graph N = len(self.graph.vertices) # node_indices = 4 node_indices = list(self.graph.vertices.keys()) plot = figure(title="Mike Kerbleski Graph", x_range=(0, 10.1), y_range=(0, 10.1), tools="", toolbar_location=None) graph_renderer = GraphRenderer() edge_start = [] edge_end = [] # print(node_indices) for vertex_id in node_indices: for v in graph.vertices[vertex_id].edges: edge_start.append(vertex_id) edge_end.append(v) graph_renderer.edge_renderer.data_source.data = dict(start=edge_start, end=edge_end) x = [] y = [] colors = [] labels = [] color1 = "red" color2 = "blue" for vertex_id in node_indices: labels.append('hello') if vertex_id in edge_start: colors.append(color1) else: colors.append(color2) vertex = graph.vertices[vertex_id] x.append(vertex.x) y.append(vertex.y) graph_renderer.node_renderer.data_source.add(node_indices, 'index') graph_renderer.node_renderer.data_source.add(colors, 'color') graph_renderer.node_renderer.glyph = Oval(height=0.1, width=0.2, fill_color="color") graph_layout = dict(zip(node_indices, zip(x, y))) graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) ### Draw quadratic bezier paths def bezier(start, end, control, steps): return [(1 - s)**2 * start + 2 * (1 - s) * s * control + s**2 * end for s in steps] plot.renderers.append(graph_renderer) output_file("graph.html") show(plot)
def plot_data(data_df, connections, year, geoSource_new): data_df_countries = data_df #.drop_duplicates(subset=None, keep='first', inplace=True) connections_df = connections node_source = ColumnDataSource( data_df_countries[["country_id", "Country", "Longitude", "Latitude"]]) edge_source = ColumnDataSource(connections_df[["start", "end"]]) node_renderer = GlyphRenderer(data_source=node_source, glyph=node_glyph, selection_glyph=node_selection, nonselection_glyph=node_nonselection) ## Create edge_renderer edge_renderer = GlyphRenderer(data_source=edge_source, glyph=edge_glyph, hover_glyph=edge_hover, selection_glyph=edge_selection, nonselection_glyph=edge_nonselection) ## Create layout_provider graph_layout = dict( zip(data_df_countries.country_id.astype(str), zip(data_df_countries.Longitude, data_df_countries.Latitude))) layout_provider = StaticLayoutProvider(graph_layout=graph_layout) ## Create graph renderer graph = GraphRenderer(edge_renderer=edge_renderer, node_renderer=node_renderer, layout_provider=layout_provider, inspection_policy=NodesAndLinkedEdges(), selection_policy=NodesAndLinkedEdges()) plot = Plot(x_range=Range1d(-150, 150), y_range=Range1d(15, 75), plot_width=800, plot_height=600, background_fill_color=Set3_12[4], background_fill_alpha=0.2) plot.title.text = "Human Trafficing Visualization for " + str(year) # plot.add_glyph( geoSource_data, Patches(xs='xs', ys='ys', line_color='grey' # , line_width=.5, fill_color=Set3_12[6], fill_alpha=0.25)) plot.add_glyph( geoSource_new, Patches(xs='xs', ys='ys', line_color='grey', line_width=.2, fill_color={ 'field': 'Tier', 'transform': mapper2 }, fill_alpha=0.25)) plot.renderers.append(graph) plot.add_layout(LinearAxis(axis_label="Latitude"), "below") plot.add_layout(LinearAxis(axis_label="Longitude"), "left") hover = HoverTool( show_arrow=True, # tooltips= # [("Country Involved: ", "@Country")], tooltips=""" <div> <div> <span style="font-size: 15px;">Country Information </span> <span style="font-size: 12px; color: #696;">@Destination_Country </span> </div> </div> """, renderers=[graph]) hover_no_tooltips = HoverTool(tooltips=None, renderers=[graph]) box_zoom = BoxZoomTool() plot.add_tools(hover, hover_no_tooltips, box_zoom, TapTool(), BoxSelectTool(), ResetTool(), WheelZoomTool()) plot.toolbar.active_inspect = [hover, hover_no_tooltips] plot.toolbar.active_drag = box_zoom plot.outline_line_color = "navy" plot.outline_line_alpha = 0.3 plot.outline_line_width = 3 plot.add_tile(STAMEN_TONER_LABELS) return plot
def generateNodeLinkGraph(file): #Reading the file file = file + '.csv' fname = os.path.join(server.config['UPLOAD_FOLDER'], file) f = open(fname, 'r') #Reading first line line1 = f.readline() names = line1[1:].split(';') # Rename duplicates since there are people with the same name seen = {} dupes = [] for index, name in enumerate(names): if name not in seen: seen[name] = 1 else: if seen[name] == 1: dupes.append((index, name)) seen[name] += 1 # add 1, 2 etc after the name for pair in dupes: index = pair[0] name = pair[1] for i in range(seen[name]): names[index] = name + str((i+1)) #print(names[index]) # Read csv df = pd.read_csv(f, names=names, sep=';') # Fix it df = df.reset_index(level=1) names.append("delete") df.columns = names del df["delete"] df.set_index([df.columns], inplace=True) # Get names again for later use names = df.columns.tolist() # Get 150*150 sub matrix since otherwise the plot is very slow.. df = df.head(150)[names[0:150]] names = df.columns.tolist() #Get total amount of nodes N = len(names) node_indices = list(range(N)) #Create list of numeric node indices # Scale for the repeating pattern of the colours scale = math.ceil(N / 256) #Iterate over dataframe and save non-zero edges start = [] #Contains starting node index of each edge end = [] #Contains ending node index of each edge tolerance = 0.75 #Determine which edges are shown and which are not index_count = 0 #Set start node index to 0 for row in df.itertuples(): #For each row in the dataframe index_count += 1 #Increase start node index by 1 element_count = 0 #(Re)set second node index to 0 for element in row: #For each element in each row element_count += 1 #Increase second node index by 1 if type(element) == float: #if element == 1.0: #Code in case for symmetric matrix, effectively halving running time of this loop # break #elif element > tolerance: if element > tolerance and not element == 1.0: start.append(index_count) #Add starting node index to the edge starting list end.append(element_count) #Add ending node index to the edge ending list #Create the plot with two axes, a title and interaction tools #plot = figure(title='Circular Node-Link Diagram', x_range=(0 - (N * 2.1) , N * 2.1), y_range=(0 - (N * 2.1) , N * 2.1), # tools='pan, wheel_zoom, reset', toolbar_location = 'right', frame_height = 400, frame_width = 400, output_backend="webgl") plot = Plot(x_range=Range1d(0 - (N * 2.1) , N * 2.1), y_range=Range1d(0 - (N * 2.1) , N * 2.1), toolbar_location = 'right', frame_height = 400, frame_width = 400, output_backend="webgl") plot.title.text = "Circular Node-Link Diagram" plot.add_tools(PanTool(), BoxZoomTool(), ResetTool()) #Create the graph object graph = GraphRenderer() #Assign the correct data for the edges #graph.edge_renderer.data_source.data = dict( # start = start, # end = end) #graph.edge_renderer.glyph = MultiLine(line_color = Viridis256[200]) #Assign the correct data for the nodes graph.node_renderer.data_source.add(node_indices, 'index') graph.node_renderer.data_source.add(Viridis256 * scale, 'color') graph.node_renderer.glyph = Circle(radius = N * 0.0025, fill_color='color') #Start of circular layout code circ = [i * 2 * math.pi/N for i in node_indices] x = [2 * N * math.cos(i) for i in circ] y = [2 * N * math.sin(i) for i in circ] #Assign the correct x and y values to all nodes graph_layout = dict(zip(node_indices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) #Arrow code test for start_index in start: start_index -= 1 for end_index in end: end_index -= 1 plot.add_layout(Arrow(end = NormalHead(fill_color = Viridis256[200], size = N * 0.1), x_start = x[start_index], y_start = y[start_index], x_end = x[end_index], y_end = y[end_index], line_color = Viridis256[200])) end_index += 1 start_index += 1 #Show the plot plot.renderers.append(graph) script, div = components(plot) return script, div
for v in value_list: size_list.append(9) if v > 10000: color_list.append(allcolor[1]) elif v > 5000: color_list.append(allcolor[2]) elif v > 0: color_list.append(allcolor[3]) else: color_list.append(allcolor[1]) for e in G.edges: width_list.append(1) print(mean(value_list)) fixed_layout_provider = StaticLayoutProvider(graph_layout=modified_pos) graph_renderer.layout_provider = fixed_layout_provider graph_renderer.node_renderer.glyph = Circle(size='size', fill_color='colors') graph_renderer.edge_renderer.glyph = MultiLine(line_color="purple", line_alpha='width', line_width=1) x, y = zip(*graph_renderer.layout_provider.graph_layout.values()) graph_renderer.node_renderer.data_source.data['x'] = x graph_renderer.node_renderer.data_source.data['y'] = y graph_renderer.node_renderer.data_source.data['colors'] = color_list graph_renderer.node_renderer.data_source.data['label'] = label_list graph_renderer.node_renderer.data_source.data['size'] = size_list graph_renderer.edge_renderer.data_source.data['width'] = width_list event_radius_dummy_1 = plot.circle(1, 1,
def create_graph(): #Find the layout and color choice if radio_layout.active == 0: lay = 'WDegreepos' elif radio_layout.active == 1: lay = 'bwcentralpos' else: lay = 'ccentralpos' if radio_color.active == 0: col = 'DegCol' elif radio_color.active == 1: col = 'Colbw' elif radio_color.active == 2: col = 'friend' elif radio_color.active == 3: col = 'reviewcount' else: col = 'comprank' # Create Network view graph = GraphRenderer() graph.node_renderer.data_source.data = nodes_df(G, col) graph.edge_renderer.data_source.data = edges_df(G) graph.node_renderer.glyph = Circle(size='size', fill_color='Col', line_color="black", line_alpha=0.1, fill_alpha=1) graph.edge_renderer.glyph = MultiLine(line_alpha='alpha', line_width=0.1, line_color="#A0DF3F") graph_layout = dict(nx.get_node_attributes(G, lay)) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) # Glyph properties on selection graph.selection_policy = NodesAndLinkedEdges() graph.inspection_policy = EdgesAndLinkedNodes() graph.node_renderer.selection_glyph = Circle(size=12, fill_color='#0A5EB6', line_color="#002217") graph.edge_renderer.selection_glyph = MultiLine(line_color="#2972BE", line_width=0.5, line_alpha=0.4) # Adding graph to plot plot = figure(title="Yelp Users Layout", x_range=(-6.5, 6.5), y_range=(-6.5, 6.5), plot_width=525, plot_height=525, toolbar_location="above") plot.outline_line_alpha = 0 plot.xgrid.grid_line_color = None plot.ygrid.grid_line_color = None plot.xaxis.visible = False plot.yaxis.visible = False plot.renderers.append(graph) plot.add_tools(TapTool()) return plot
def show(self): # color1 = [Viridis256[1]]*len(self.vertices) # color2 = Viridis10 # currentcolor = color1 colors = [] # [orange, white, ] i = random.randint(0, 256) for g in self.graphIn.groups: colors += [Viridis256[i]] * len(g) i = random.randint(0, 256) print(colors) node_indices = self.vertices plot = figure(title='Graph Layout Demonstration', x_range=(-1.1, 1.1), y_range=(-1.1, 1.1), tools='', toolbar_location=None) graph = GraphRenderer() graph.node_renderer.data_source.add([ vertex for subgroup in self.graphIn.groups for vertex in subgroup ], 'index') # [6,7,1,2,3,4,5] graph.node_renderer.data_source.add( colors, 'color' ) #graph.groups = [[6], [7], [1,2,3,4,5]] [orange, purp, gray, gray, gray, gray, gray] graph.node_renderer.glyph = Circle(radius=0.1, fill_color='color', name=str(node_indices)) starts = [] for k in self.graphIn.vertices.keys(): starts += [k] * (len(self.graphIn.vertices[k])) ends = [] for k, v in self.graphIn.vertices.items(): ends += v graph.edge_renderer.data_source.data = dict(start=starts, end=ends) circ = [ int(i) * 2 * math.pi / len(self.vertices) for i in node_indices ] x = [math.cos(i) for i in circ] y = [math.sin(i) for i in circ] graph_layout = dict(zip(node_indices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) # setup labels data = {'x': x, 'y': y, 'name': node_indices} source = ColumnDataSource(data) labels = LabelSet(x="x", y="y", text="name", y_offset=-5, text_font_size="12pt", text_color="white", source=source, text_align='center') plot.add_layout(labels) plot.renderers.append(graph) output_file('graph2.html') show(plot)
G_lps3 = nx.from_pandas_edgelist(pd.DataFrame(src_lps3.data)) graph_renderer_lps3 = from_networkx(G_lps3, nx.circular_layout, scale=1, center=(0, 0)) node_indices_lps3 = list(range(p_lps3)) circ = [i * 2 * np.pi / p_lps3 for i in node_indices_lps3] x = np.array([x_layout(t) for t in circ]) y = np.array([y_layout(t) for t in circ]) scale = np.max([x, y]) x = (x - np.mean(x)) / (scale - np.mean(x)) y = (y - np.mean(y)) / (scale - np.mean(y)) graph_layout = dict(zip(node_indices_lps3, zip(x, y))) graph_renderer_lps3.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) plot_lps3.renderers.append(graph_renderer_lps3) controls_lps3 = WidgetBox(p_select_lps3, div_lps3) # Create a row layout layout_lps3 = row(controls_lps3, plot_lps3) # Make a tab with the layout tab_lps3 = Panel(child=layout_lps3, title='LPS3') ###################################################################### # Paley graph ######################################################################
def show(self): #Get list of nodes nodes = list(self.graph.vertices.keys()) #Create plot figure plot = figure(title='Graph Plot', x_range=(-1.5, 1.5), y_range=(-1.5, 1.5), tools="", toolbar_location=None) #create a GraphRenderer Object G = GraphRenderer() #map nodes to node_renderer and format glyph for nodes G.node_renderer.glyph = Circle(radius=0.1, fill_color="fill_color") G.node_renderer.data_source.data = dict(index=nodes, fill_color=['orange'] * len(nodes)) #Get start and end list of edges edge_starts = [] edge_ends = [] for k, v in self.graph.vertices.items(): edge_starts += [k] * len(v) edge_ends += v #map data to edge_renderer and format glyph for edges G.edge_renderer.glyph = MultiLine(line_color="#cccccc", line_alpha=0.8, line_width=2) G.edge_renderer.data_source.data = dict(start=edge_starts, end=edge_ends) #add hover effects for nodes and edges G.node_renderer.hover_glyph = Circle(radius=0.3) G.edge_renderer.hover_glyph = MultiLine(line_color='#abdda4', line_width=4) # When we hover over nodes, highlight adjecent edges too G.inspection_policy = NodesAndLinkedEdges() #setup layout coordinates circ = [i * 2 * math.pi / len(nodes) for i in range(len(nodes))] x = [math.cos(i) for i in circ] y = [math.sin(i) for i in circ] graph_layout = dict(zip(nodes, zip(x, y))) G.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) #setup labels data = {'x': x, 'y': y, 'name': nodes} source = ColumnDataSource(data) labels = LabelSet(x="x", y="y", text="name", y_offset=-5, text_font_size="12pt", text_color="#555555", source=source, text_align='center') #add plot.renderers.append(G) #Add hovering tool plot.add_tools(HoverTool(tooltips=None)) #Add node label plot.add_layout(labels) #save file to graph.html output_file('graph.html') #show plot show(plot) # #create graph # graph = Graph() # #Add vertexes # graph.add_vertex('v1') # graph.add_vertex('v2') # graph.add_vertex('v3') # graph.add_vertex('v4') # graph.add_vertex('v5') # graph.add_vertex('v6') # graph.add_vertex('v7') # graph.add_vertex('v8') # graph.add_vertex('v9') # graph.add_vertex('v10') # graph.add_vertex('v11') # graph.add_vertex('v12') # graph.add_vertex('v13') # graph.add_vertex('v14') # #add edges # graph.add_directed_edge('v1', 'v2') # graph.add_directed_edge('v2', 'v1') # graph.add_directed_edge('v2', 'v7') # graph.add_directed_edge('v3', 'v8') # graph.add_directed_edge('v5', 'v6') # graph.add_directed_edge('v5', 'v10') # graph.add_directed_edge('v6', 'v5') # graph.add_directed_edge('v6', 'v7') # graph.add_directed_edge('v7', 'v2') # graph.add_directed_edge('v7', 'v6') # graph.add_directed_edge('v8', 'v3') # graph.add_directed_edge('v8', 'v7') # graph.add_directed_edge('v8', 'v9') # graph.add_directed_edge('v8', 'v13') # graph.add_directed_edge('v9', 'v8') # graph.add_directed_edge('v9', 'v14') # graph.add_directed_edge('v10', 'v5') # graph.add_directed_edge('v12', 'v13') # graph.add_directed_edge('v13', 'v12') # graph.add_directed_edge('v13', 'v8') # graph.add_directed_edge('v13', 'v14') # graph.add_directed_edge('v14', 'v13') # graph.add_directed_edge('v14', 'v9') # bokeh_graph = BokehGraph(graph) # bokeh_graph.show()