def show(self): N = len(self.graph.vertices.keys()) #length of vertices node_indices = list(range(N)) plot = figure(title="Graph of Nodes and Edges", 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) circ = [ i * 2 * math.pi / len(self.graph.vertices.keys()) 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) plot.renderers.append(graph) output_file('graph.html') show(plot)
def make_user_graph(self, data, top_level_name, oval_height = 0.1, oval_width=0.2, branch_depth = .6, top_color = Spectral8[0], second_level_color = Spectral8[1] , third_level_color = Spectral8[2], label_x_offset = -15, label_y_offset = 10, p = None, max_num_in_row = 5, line_width = .5 ): if not p: p = figure(title="Test Ad Graph", x_range=(-1.1,1.1), y_range=(-1.1,1.1), tools="", toolbar_location=None, plot_width = 1000) graph = GraphRenderer() graph.node_renderer.glyph = Oval(height=oval_height, width=oval_width, fill_color="fill_color", name="text") node_indices = [x for x in range(self._make_node_indices(data))] second_level_pos, third_level_pos = self._make_pos_dict(data) graph.node_renderer.data_source.data = dict(index=node_indices, fill_color=self._make_fill_colors( second_level_pos, third_level_pos, second_level_color = second_level_color, third_level_color = third_level_color, top_color = top_color)) eds, edge_widths, edge_colors = self._make_edges(second_level_pos, third_level_pos, data, default_width = line_width) graph.edge_renderer.data_source.data = eds graph_layout= self._make_layout(second_level_pos = second_level_pos, third_level_pos = third_level_pos, depth = branch_depth, max_num = max_num_in_row) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) p.add_layout(self._make_labels(graph_layout = graph_layout, second_level_pos = second_level_pos, third_level_pos = third_level_pos, x_offset = label_x_offset, y_offset = label_y_offset, top_level_name = top_level_name)) graph.edge_renderer.data_source.data["line_width"] = edge_widths graph.edge_renderer.glyph.line_width = {'field': 'line_width'} graph.edge_renderer.data_source.data["line_color"] = edge_colors graph.edge_renderer.glyph.line_color = {'field': 'line_color'} p.renderers.append(graph) return p
def _setup_graph_renderer(self, circle_size, draw_components): #graph_renderer will have the actual logic for drawing graph_renderer = GraphRenderer() self.vertex_keys = list(self.graph.vertices.keys()) # add the vertex data as instructions for drawing nodes graph_renderer.node_renderer.data_source.add( [vertex.label for vertex in self.vertex_keys], 'index') if draw_components: graph_renderer.node_renderer.data_source.add( self._get_connected_component_colors(), "color") else: graph_renderer.node_renderer.data_source.add( self._get_random_colors(), "color") graph_renderer.node_renderer.glyph = Circle(size=circle_size, line_color="black", fill_color="color") graph_renderer.edge_renderer.data_source.data = self._get_edge_indices( ) self.randomize() self.plot.add_layout(Title(text="Whys", align="left"), "left") self.plot.add_layout(Title(text="Exes", align="center"), "below") graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=self.pos) self.plot.renderers.append(graph_renderer)
def show(self): node_indices = list(self.graph.vertices.keys()) x_value = [x for (x, y) in self.graph.vertices.items()] y_value = [list(y) for (x, y) in self.graph.vertices.items()] plot = figure(title="Graph Layout", x_range=(0, 4), y_range=(0, 4), tools="", toolbar_location=None) graph = GraphRenderer() graph.node_renderer.data_source.add(x_value, 'index') graph.node_renderer.data_source.add(Spectral8, 'color') graph.node_renderer.glyph = Circle(radius=0.1, fill_color='color') print("\n x value: ", x_value) print("\n y value: ", y_value) graph.edge_renderer.data_source.data = dict(start=x_value, end=y_value) circ = [int(i) for i in x_value] x = [i for i in circ] y = [math.sin(i) for i in circ] # sinus shape graph_layout = dict(zip(x_value, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) plot.renderers.append(graph) 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) # 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 return row(plot)
def _setup_graph_renderer(self, circle_size, draw_components): # The renderer will have the actual logic for drawing graph_renderer = GraphRenderer() # Saving vertices in an arbitrary but persistent order self.vertex_list = list(self.graph.vertices.keys()) # Add the vertex data as instructions for drawing nodes graph_renderer.node_renderer.data_source.add( [vertex.label for vertex in self.vertex_list], 'index') colors = (self._get_connected_component_colors() if draw_components else self._get_random_colors()) graph_renderer.node_renderer.data_source.add(colors, 'color') # And circles graph_renderer.node_renderer.glyph = Circle(size=circle_size, fill_color='color') graph_renderer.node_renderer.hover_glyph = Circle( size=circle_size, fill_color=Category20[20][9]) graph_renderer.node_renderer.selection_glyph = Circle( size=circle_size, fill_color=Category20[20][6]) # Add the edge [start, end] indices as instructions for drawing edges graph_renderer.edge_renderer.data_source.data = self._get_edge_indexes( ) self.randomize() # Randomize vertex coordinates, and set as layout graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=self.pos) # Attach the prepared renderer to the plot so it can be shown graph_renderer.selection_policy = NodesAndLinkedEdges() graph_renderer.inspection_policy = EdgesAndLinkedNodes() self.plot.renderers.append(graph_renderer) print(graph_renderer.node_renderer) tool = PointDrawTool(renderers=[graph_renderer.node_renderer]) self.plot.add_tools(tool)
def report_html_graph(logger, iteration=0): # type: (Logger, int) -> () """ reporting bokeh graph (html) to debug samples section :param logger: The task.logger to use for sending the plots :param iteration: The iteration number of the current reports """ nodes = 8 node_indices = list(range(nodes)) 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] * nodes, 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) plot.renderers.append(graph) output_file("graph.html") save(plot) logger.report_media("html", "Graph_html", iteration=iteration, local_path="graph.html")
def _setup_graph_renderer(self, circle_size, draw_components): # The renderer will have the actual logic for drawing graph_renderer = GraphRenderer() # Saving vertices in an arbitrary but persistent order self.vertex_list = list(self.graph.vertices.values()) # .keys is getting the key from each key-value pair in self.graph.vertices # Therefore, we get a list of integers # print(f"self.vertex_list: {self.vertex_list}") # Add the vertex data as instructions for drawing nodes graph_renderer.node_renderer.data_source.add( [vertex.label for vertex in self.vertex_list], 'index') """ PY [vertex.label for vertex in self.vertex_list] === JS this.vertex_list.map(vertex => vertex.label) """ colors = (self._get_connected_component_colors() if draw_components else self._get_random_colors()) graph_renderer.node_renderer.data_source.add(colors, 'color') # And circles graph_renderer.node_renderer.glyph = Circle(size=circle_size, fill_color='color') # Add the edge [start, end] indices as instructions for drawing edges graph_renderer.edge_renderer.data_source.data = self._get_edge_indexes( ) self.randomize() # Randomize vertex coordinates, and set as layout graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=self.pos) # Attach the prepared renderer to the plot so it can be shown self.plot.renderers.append(graph_renderer)
def __init__(self, lilgraph): self.lilgraph = lilgraph self.keys = [] self.values = [] for key in self.lilgraph.vertices: for value in self.lilgraph.vertices[key].edges: self.keys.append(key) self.values.append(value) vertices = list(lilgraph.vertices.keys()) plot = figure(title='One heckin graph', x_range=(-1.1, 1.1), y_range=(-1.1, 1.1), tools='', toolbar_location=None) graph = GraphRenderer() graph.node_renderer.data_source.add(vertices, 'index') graph.node_renderer.glyph = Oval(height=0.05, width=0.05, fill_color='pink') graph.edge_renderer.data_source.data = dict(start=self.keys, end=self.values) circ = [i * 2 * math.pi / 8 for i in vertices] x = [math.cos(i) for i in circ] y = [math.sin(i) for i in circ] graph_layout = dict(zip(vertices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) plot.renderers.append(graph) show(plot) output_file('graph.html')
def _setup_graph_renderer(self, circle_size, draw_components): # The renderer will have the actual logic for drawing graph_renderer = GraphRenderer() # Saving vertices in an arbitrary but persistent order self.vertex_list = list(self.graph.vertices.keys()) # Add the vertex data as instructions for drawing nodes graph_renderer.node_renderer.data_source.add( [vertex.label for vertex in self.vertex_list], 'index') print("\nRandom Colors") print(self._get_random_colors(len(self.vertex_list))) colors = (self._get_connected_component_colors() if draw_components else self._get_random_colors(len(self.vertex_list))) graph_renderer.node_renderer.data_source.add(colors, 'color') # And circles graph_renderer.node_renderer.glyph = Circle(size=circle_size, fill_color='color') # Add the edge [start, end] indices as instructions for drawing edges graph_renderer.edge_renderer.data_source.data = self._get_edge_indexes() self.randomize() # Randomize vertex coordinates, and set as layout graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=self.pos) # Attach the prepared renderer to the plot so it can be shown self.plot.renderers.append(graph_renderer)
def show(self): node_indices = list(self.graph.keys()) plot = figure(title="Graph Layout Render", x_range=(-1.1, 10.1), y_range=(-1.1, 10.1), tools="", toolbar_location=None) graph = GraphRenderer() graph.node_renderer.data_source.add(node_indices, 'index') graph.node_renderer.data_source.add(['red'] * self.size, 'color') graph.node_renderer.glyph = Circle(radius=0.25, fill_color='color') start_indices = [] end_indices = [] for vertex in self.graph: for edge_end in self.graph[vertex]: start_indices.append(vertex) end_indices.append(edge_end) ### start of layout code circ = [int(v) for v in g.vertices] 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) plot.renderers.append(graph) output_file('graph.html') show(plot)
def _setup_graph_renderer(self, circle_size): graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add( list(self.graph.vertices.keys()), "index") graph_renderer.node_renderer.data_source.add(self._get_random_colors(), "color") graph_renderer.node_renderer.glyph = Circle(size=circle_size, fill_color="color") graph_renderer.edge_renderer.data_source.data = self._get_edge_indexes( ) self.randomize() for i in range( len(graph_renderer.edge_renderer.data_source.data["start"])): self.plot.add_layout( Arrow( end=VeeHead(size=20, fill_color="black"), x_start=self.pos[graph_renderer.edge_renderer.data_source. data["start"][i]][0], y_start=self.pos[graph_renderer.edge_renderer.data_source. data["start"][i]][1], x_end=self.pos[graph_renderer.edge_renderer.data_source. data["end"][i]][0], y_end=self.pos[graph_renderer.edge_renderer.data_source. data["end"][i]][1], )) graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=self.pos) self.plot.renderers.append(graph_renderer) self._get_labels()
def draw(self): graph = self.graph N = len(graph.vertices) node_indices = list(graph.vertices.keys()) print(f"node indices: {node_indices}") plot = figure(title='Graph Layout Demonstration', x_range=(-10, 10), y_range=(-10, 10), tools='', toolbar_location=None) graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add(node_indices, 'index') # graph.node_renderer.data_source.add(Spectral8, 'color') graph_renderer.node_renderer.glyph = Oval(height=0.6, width=0.5, fill_color='red') graph_renderer.edge_renderer.data_source.data = dict(start=[0] * N, end=node_indices) d = dict(start=[0] * N, end=node_indices) print(f"dict: {d}") ### 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) 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_edge('0', '1') # graph.add_edge('0', '3') # print(graph.vertices) # bg = BokehGraph(graph) # bg.draw()
def show(self): N = len(self.graph.vertices) node_indices = list(self.graph.vertices.keys()) 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 = Circle(radius=0.1, 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 / N 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) plot.renderers.append(graph) output_file('graph.html') show(plot)
def _setup_graph_renderer(self, circle_size, draw_components): # The renderer will have the actual logic for drawing graph_renderer = GraphRenderer() # Saving vertices in an arbitrary but persistent order self.vertex_keys = list(self.graph.vertices.keys()) # Add the vertex data as instructions for drawing nodes graph_renderer.node_renderer.data_source.add( [vertex.label for vertex in self.vertex_keys], 'index') # Connected Components will be the same color # island components will be random colors colors = (self._color_connected_components() if draw_components else self._RCG()) graph_renderer.node_renderer.data_source.add(colors, 'color') # give the vertice shape graph_renderer.node_renderer.glyph = Circle(size=circle_size, fill_color='color') # Add the edge [start, end] indices as instructions for drawing edges graph_renderer.edge_renderer.data_source.data = self._get_edge_indexes( ) # Randomize vertex coordinates, and set as layout self.randomize() # destructure this a little to squish a long line _layout = StaticLayoutProvider(graph_layout=self.position) graph_renderer.layout_provider = _layout # Attach the prepared renderer to the plot so it can be shown self.plot.renderers.append(graph_renderer)
def draw(self, title='Graph', width=10, height=10, show_axis=False, show_grid=False, circle_size=25): plot = figure(title=title, x_range=(0, width), y_range=(0, height)) plot.axis.visible = show_axis plot.grid.visible = show_grid graph = GraphRenderer() graph.node_renderer.data_source.add(self._get_indices(), 'index') graph.node_renderer.data_source.add(self._get_colors(), 'color') graph.node_renderer.glyph = Circle(size=circle_size, fill_color='color') graph.edge_renderer.data_source.data = self._get_edges() self._map_coords(width, height) graph.layout_provider = StaticLayoutProvider(graph_layout=self.pos) plot.renderers.append(graph) labels = self._setup_labels() plot.add_layout(labels) output_file('./graph.html') show(plot)
def create_decision_tree_graph_renderer(plot, tree): """Crea el renderizador del gráfico del árbol de decisión. Para ello se deben especificar configuraciones como: indices o identificadores de los nodos, colores de los nodos, tipos de figura de los nodos, tipos de figura de relación entre nodo y las relaciones entre los nodos (inicio y final). Parameters: plot (Figure): Figura Bokeh donde se muestra el árbol de decisión. tree (Tree): Estructura del árbol de decisión a mostrar. Returns: GraphRenderer: Renderizador del gráfico del árbol de decisión. """ node_indices = [node.id for node in tree.node_list] node_colors = [node.color for node in tree.node_list] start, end = tree.get_nodes_relations() x, y = tree.get_layout_node_positions(plot) graph_layout = dict(zip(node_indices, zip(x, y))) graph = GraphRenderer() graph.node_renderer.data_source.add(node_indices, 'index') graph.node_renderer.data_source.add(node_colors, 'color') graph.node_renderer.glyph = Rect(height=0.15, width=0.2, fill_color='color') graph.edge_renderer.glyph = MultiLine(line_color='#b5b8bc', line_alpha=0.8, line_width=5) graph.edge_renderer.data_source.data = dict(start=start, end=end) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) return graph
def draw(self): print('self.graph.vertices:', self.graph.vertices) N = len(self.graph.vertices) node_indices = list(self.graph.vertices.keys()) print('node_indices:', node_indices) plot = figure(title="Graph Layout Demonstration", x_range=(-7, 7), y_range=(-7, 7), tools="", toolbar_location=None) graph = GraphRenderer() graph.node_renderer.data_source.add(node_indices, 'index') graph.node_renderer.data_source.add(Spectral5, 'color') graph.node_renderer.glyph = Oval(height=0.5, width=0.5, fill_color="color") print(f"self.keys: {self.keys} self.values: {self.values}") graph.edge_renderer.data_source.data = dict(start=self.keys, end=self.values) ## start of layout code circ = [int(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.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 output_file("graph.html") show(plot)
def show(self): """ this method makes use of the bokeh package to produce a graph in html """ vertex_indices = list(self.graph.vertices.keys()) print(vertex_indices[0], "starting point for traversal") self.graph.depth_first(vertex_indices[0]) self.graph.breadth_first(vertex_indices[0]) plot = figure(title="Random Generated Graph", x_range=(-7, 7), y_range=(-7, 7), tools='', toolbar_location=None) graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add(vertex_indices, 'index') edge_start = [] edge_end = [] for vertex_id in vertex_indices: for vertices_edges in self.graph.vertices[vertex_id].edges: edge_start.append(vertex_id) edge_end.append(vertices_edges) for vertex_id in vertex_indices: vertex = self.graph.vertices[vertex_id] self.x_coordinates.append(vertex.coordination_x) self.y_coordinates.append(vertex.coordination_y) if vertex_id in edge_start: self.colors_layout.append(self.connected_color) else: self.colors_layout.append(self.disconnected_color) graph_renderer.node_renderer.data_source.add(self.colors_layout, 'color') graph_renderer.node_renderer.glyph = Circle(radius=0.5, fill_color='color') graph_renderer.edge_renderer.data_source.data = dict(start=edge_start, end=edge_end) graph_layout = dict( zip(vertex_indices, zip(self.x_coordinates, self.y_coordinates))) graph_renderer.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) plot.renderers.append(graph_renderer) label_source = ColumnDataSource(data=dict(x=self.x_coordinates, y=self.y_coordinates,\ names=[self.graph.vertices[vertex_id].value for vertex_id in self.graph.vertices])) labels = LabelSet(x='x', y='y', text='names', level='glyph', \ text_align='center', text_baseline='middle', source=label_source, \ render_mode='canvas', text_color='white') plot.add_layout(labels) output_file('random.html') show(plot)
def vis2(result, d_type, G): if result == -1: #----- if graph is not connected! print("Not connected!") else: indices = set() # to store nodes start = [] # to store start and enf of each edge end = [] edge_color = [] #to recognize output from other edges for item in result: #add nodes indices.add(item[0]) indices.add(item[1]) indices = list(indices) for node in indices: #add edges for v in G.neighboors[node]: if v in indices: start.append(node) end.append(v) if ((node, v) in result) or ((v, node) in result): #if it's in output give it a color if d_type == 't': edge_color.append('red') elif d_type == 'd': edge_color.append('blue') else: edge_color.append('green') else: edge_color.append('black') #else it would be black x = [] y = [] for node in indices: #convert longitude, latitude to mercator coordinates xy = create_coordinates(G.coord_nodes[node][0]/1000000, G.coord_nodes[node][1]/1000000) x.append(xy[0]) y.append(xy[1]) tile_provider = get_provider(Vendors.CARTODBPOSITRON) #output_notebook() # range bounds supplied in web mercator coordinates m = figure(plot_width=800, plot_height=400, x_range=(min(x)-200, max(x)+200), #span of the map y_range=(min(y)-200, max(y)+200), x_axis_type='mercator', y_axis_type='mercator') m.add_tile(tile_provider) graph = GraphRenderer() #initializing the graph graph.node_renderer.data_source.add(indices, 'index') graph.node_renderer.glyph = Oval(height=20, width=20, fill_color='black') graph.edge_renderer.data_source.data = dict( start = start, end = end) graph.edge_renderer.data_source.add(edge_color, 'color') graph.edge_renderer.glyph = MultiLine(line_color='color', line_alpha=0.8, line_width=2) graph_layout = dict(zip(indices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) m.renderers.append(graph) #assigning the graph to the map show(m)
def show(self): graph = self.graph N = len(graph.vertices) node_indices = list(graph.vertices) plot = figure(title='Graph', x_range=(self.x_min, self.x_max), y_range=(self.y_min, self.y_max)) graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add(node_indices, 'index') graph_renderer.node_renderer.data_source.add(Spectral8[0:N], 'color') graph_renderer.node_renderer.glyph = Circle(radius=0.2, fill_color='color') start_indices = [] end_indices = [] for vertex in graph.vertices: for other_vert in graph.vertices[vertex].edges: start_indices.append(vertex) end_indices.append(other_vert) graph_renderer.edge_renderer.data_source.data = dict( start=start_indices, end=end_indices) circ = [n * 2 * math.pi / 8 for n 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_renderer.layout_provider = StaticLayoutProvider( graph_layout=graph_layout) 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.renderers.append(graph_renderer) plot.add_layout(labels) output_file('graph.html') show(plot)
def make_plot(self): model, word, n = self.model, self.word, self.n G_words = self.find_similar_words(model, word, n) G_weights = self.find_similar_weights(model, word, n) N = len(G_words) node_indices = list(range(N)) plot = figure( plot_width=500, plot_height=500, x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1), tools="", background_fill_color="white", x_axis_location=None, y_axis_location=None, ) plot.title.text = "Word Similarity Graph" plot.xgrid.visible = False plot.ygrid.visible = False node_hover_tool = HoverTool(tooltips=[("word", "@word")]) plot.add_tools(node_hover_tool, BoxZoomTool(), ResetTool()) graph = GraphRenderer() graph.node_renderer.data_source.add(node_indices, 'index') graph.node_renderer.data_source.add(G_words, 'word') graph.node_renderer.data_source.add(G_weights, 'weight') graph.node_renderer.glyph = Circle(size=15, fill_color="black") graph.edge_renderer.data_source.data = dict(start=[0] * N, end=node_indices) graph.edge_renderer.glyph = MultiLine(line_alpha=0.8, line_cap='square', line_dash='solid') red = Color("black") colors = list(red.range_to(Color("red"), N + 1)) colors = [color.hex for color in colors] graph.edge_renderer.data_source.data["line_color"] = colors[1:] graph.edge_renderer.glyph.line_color = {'field': 'line_color'} graph.edge_renderer.data_source.data["line_width"] = G_weights graph.edge_renderer.glyph.line_width = {'field': 'line_width'} circ = [i * 2 * math.pi / N for i in node_indices] x = [math.cos(i) for i in circ] x[0] = 0.0 y = [math.sin(i) for i in circ] y[0] = 0.65 graph_layout = dict(zip(node_indices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) plot.renderers.append(graph) return plot
def vis4(result, d_type, G): if result == -1: #----- if graph is not connected! print("Not possible!") else: indices = set() # to store nodes start = [] # to store start and end of each edge end = [] start.append(result[0]) for item in result[1:]: #add nodes indices.add(item) start.append(item) end.append(item) start = start[:-1] indices = list(indices) x = [] y = [] for node in indices: #convert longitude, latitude to mercator coordinates xy = create_coordinates(G.coord_nodes[node][0] / 1000000, G.coord_nodes[node][1] / 1000000) x.append(xy[0]) y.append(xy[1]) tile_provider = get_provider(Vendors.CARTODBPOSITRON) #output_notebook() # range bounds supplied in web mercator coordinates m = figure( plot_width=800, plot_height=400, x_range=(min(x) - 200, max(x) + 200), #span of the map y_range=(min(y) - 200, max(y) + 200), x_axis_type='mercator', y_axis_type='mercator') m.add_tile(tile_provider) graph = GraphRenderer() #initializing the graph graph.node_renderer.data_source.add(indices, 'index') edge_color = 'black' if d_type == 'd': edge_color = 'blue' elif d_type == 't': edge_color = 'yellow' elif d_type == 'n': edge_color = 'green' graph.node_renderer.glyph = Oval(height=20, width=20, fill_color='red') graph.edge_renderer.data_source.data = dict(start=start, end=end) graph.edge_renderer.glyph = MultiLine(line_color=edge_color, line_alpha=0.8, line_width=2) graph_layout = dict(zip(indices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) m.renderers.append(graph) #assigning the graph to the map show(m)
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)
def show(self): node_indices = list(self.graph.vertices) #x_value = [x for (x, y) in self.graph.vertices] #y_value = [y for (x, y) in self.graph.vertices] plot = figure(title="Graph Layout", x_range=(-2, 10), y_range=(-2, 10), 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 = Circle(radius=0.3, fill_color='color') #print("\n x value: ", x_value) #print("\n y value: ", y_value) start_indices = [] end_indices = [] for vertex_id in self.graph.vertices: for edge_end in self.graph.vertices[vertex_id].edges: start_indices.append(vertex_id) end_indices.append(edge_end) graph.edge_renderer.data_source.data = dict(start=start_indices, end=end_indices) grid = [int(i) for i in self.graph.vertices] x = [self.graph.vertices[node].x for node in self.graph.vertices] y = [self.graph.vertices[node].y for node in self.graph.vertices] graph_layout = dict(zip(node_indices, zip(x, y))) graph.layout_provider = StaticLayoutProvider(graph_layout=graph_layout) plot.renderers.append(graph) 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) output_file('graph.html') show(plot)
def _setup_graph_renderer(self, circle_size): graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add( list(self.graph.vertices.keys()), 'index') graph_renderer.node_renderer.data_source.add( self._get_random_colors(), 'color') graph_renderer.node_renderer.glyph = Circle(size=circle_size, fill_color='color') graph_renderer.edge_renderer.data_source.data = self._get_edge_indexes() self.randomize() graph_renderer.layout_provider = StaticLayoutProvider(graph_layout=self.pos) self.plot.renderers.append(graph_renderer)
def show(self): N = len(graph.vertices) node_indices = list(graph.vertices) plot = figure(title='Graph', x_range=(-2, 5), y_range=(-2, 5), tools='', toolbar_location=None) graph_renderer = GraphRenderer() graph_renderer.node_renderer.data_source.add(node_indices, 'index') graph_renderer.node_renderer.data_source.add( [v.color for v in graph.vertices], 'color') graph_renderer.node_renderer.glyph = Circle(radius=0.2, fill_color='color') start_indices = [] end_indices = [] for vertex_id in graph.vertices: for edge_end in graph.vertices[vertex_id]: 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 grid = [int(v) for v in graph.vertices] x = [graph.vertices[vertex_id].x for vertex_id in graph.vertices] y = [graph.vertices[vertex_id].y for vertex_id in graph.vertices] # 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) output_file('graph.html') show(plot)
def draw(self): graph = self.graph N = len(graph.vertices) node_indices = list(graph.vertices.keys()) print(node_indices) 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', 'blue', 'green', 'yellow', 'black', 'pink', 'purple', 'white' ] graph_renderer.node_renderer.data_source.add(node_colors, 'color') graph_renderer.node_renderer.glyph = Rect(height=0.1, width=0.2, fill_color='color') graph_renderer.edge_renderer.data_source.data = dict(start=[0] * N, end=node_indices) d = dict(start=[0] * N, end=node_indices) print(d) # 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) 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, 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) output_file('graph.html') show(plot)
def show(self): node_indices = self.vertices endpoints = self.endpoints 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(Viridis10, 'color') 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)
import math from bokeh.io import show, output_file from bokeh.plotting import figure from bokeh.models import GraphRenderer, StaticLayoutProvider, Oval from bokeh.palettes import Spectral8 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.data = dict( index=node_indices, fill_color=Spectral8) graph.node_renderer.glyph = Oval(height=0.1, width=0.2, fill_color="fill_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)