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 test_html(name):
# Use a breakpoint in the code line below to debug your script.
print(f'Hi, {name}')
G = nx.karate_club_graph()
plot = Plot(plot_width=400, plot_height=400,
x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1))
plot.title.text = "Graph Interaction Demonstration"
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool())
graph_renderer = from_networkx(G, nx.circular_layout, scale=1, center=(0, 0))
graph_renderer.node_renderer.glyph = Circle(size=15, fill_color=Spectral4[0])
graph_renderer.node_renderer.selection_glyph = Circle(size=15, fill_color=Spectral4[2])
graph_renderer.node_renderer.hover_glyph = Circle(size=15, fill_color=Spectral4[1])
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC", line_alpha=0.8, line_width=5)
graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color=Spectral4[2], line_width=5)
graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1], line_width=5)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
plot.renderers.append(graph_renderer)
output_file("interactive_graphs.html")
show(plot)
def get_graph(self):
start = self.data['Start']
end = self.data['End']
fl = self.data['Index']
fio = self.data['FIO']
node_indices = end.append(pd.Series(pd.Series.unique(self.data['Start'])), ignore_index=True)
#fl = pd.Series.unique(self.data['Index'])
#fl = self.data['Index']
#edges = zip(start, end)
edges =[]
for i in range(len(start)):
edges.append(tuple([start[i], end[i], {'OGRNIP': str(fl[i]) + " - " + str(fio[i])}]))
G = nx.Graph()
G.add_nodes_from(node_indices)
G.add_edges_from(edges)
#print(G.adj.items())
#print(G.edges.data())
ogrns =[]
for item in G.edges.data():
#print(item[2]['OGRNIP'])
ogrns.append(item[2]['OGRNIP'])
tooltips=[
#("index", "$index"),
#("(x,y)", "($x, $y)"),
("1 - ОГРН", "@start"),
("2 - ОГРН", "@end"),
("ФЛ", "@OGRNIP"),
#("Моя подсказка", "@end"),
]
# hover = HoverTool(tooltips=tooltips)
p = figure(plot_width=self.width, plot_height=self.height, x_range=(-3.1, 3.1), y_range=(-3.1, 3.1),
x_axis_type=None, y_axis_type=None, tools=[],
min_border=0, outline_line_color="white")
# p.add_tools(WheelZoomTool())
# p.add_tools(PanTool())
p.add_tools(HoverTool(tooltips=tooltips), TapTool(), BoxSelectTool(), WheelZoomTool(), PanTool())
#graph = from_networkx(G, nx.circular_layout, scale=1, center=(0, 0))
graph = from_networkx(G, nx.spring_layout, scale=2, center=(0, 0))
graph.node_renderer.glyph = Circle(size=5, fill_color="gray")
graph.node_renderer.hover_glyph = Circle(size=5, fill_color="red")
graph.node_renderer.selection_glyph = Circle(size=5, fill_color="green")
graph.edge_renderer.glyph = MultiLine(line_color="#CCCCCC", line_alpha=0.8, line_width=1)
graph.edge_renderer.selection_glyph = MultiLine(line_color="gray", line_width=1)
graph.edge_renderer.hover_glyph = MultiLine(line_color="gray", line_width=1)
graph.selection_policy = NodesAndLinkedEdges()
graph.inspection_policy = EdgesAndLinkedNodes()
# print(graph.node_renderer.data_source.data)
# print(graph.edge_renderer.data_source.data)
graph.edge_renderer.data_source.data['OGRNIP'] = ogrns
#print(graph.edge_renderer.data_source.data)
#print(graph.node_renderer.data_source.data)
p.renderers.append(graph)
return p
def create_cit_map(nodes, edges):
G = nx.DiGraph()
G.add_nodes_from(nodes)
G.add_edges_from(edges)
plot = Plot(plot_width=800, plot_height=800, x_range=Range1d(-1.1,1.1), y_range=Range1d(-1.1,1.1))
plot.title.text = ""
graph_renderer = from_networkx(G, nx.kamada_kawai_layout, scale=1)
graph_renderer.node_renderer.glyph = Circle(size=15)
graph_renderer.node_renderer.selection_glyph = Circle(size=15)
graph_renderer.node_renderer.hover_glyph = Circle(size=15)
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC", line_alpha=0.8, line_width=5)
graph_renderer.edge_renderer.selection_glyph = MultiLine(line_width=5)
graph_renderer.edge_renderer.hover_glyph = MultiLine(line_width=5)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
pos = graph_renderer.layout_provider.graph_layout
x,y=zip(*pos.values())
source = ColumnDataSource({'x':x,'y':y,'names': nodes})
labels = LabelSet(x='x', y='y', text='names', source=source, level='glyph', x_offset=5, y_offset=5)
plot.renderers.append(labels)
plot.renderers.append(graph_renderer)
#plot.add_layout(labels)
output_file("interactive_graphs.html")
show(plot)
def graphNetwork(data, tags):
G = nx.from_numpy_matrix(data)
graph_plot = Plot(plot_width=800,
plot_height=800,
x_range=Range1d(-1.1, 1.1),
y_range=Range1d(-1.1, 1.1))
graph_plot.title.text = "Graph.\nTotal Nodes: %i\nTotal Edges: %i" % (
G.number_of_nodes(), G.number_of_edges())
node_hover_tool = HoverTool(tooltips=[("hashtag", "@hashtag")])
graph_plot.add_tools(node_hover_tool, BoxZoomTool(), ResetTool(),
WheelZoomTool(), BoxSelectTool())
graph_renderer = from_networkx(G, nx.spring_layout, scale=1, center=(0, 0))
graph_renderer.node_renderer.glyph = Circle(size=15, fill_color='#277bb6')
graph_renderer.node_renderer.hover_glyph = Circle(size=18,
fill_color='#E84A5F')
graph_renderer.edge_renderer.glyph = MultiLine(line_color="gray",
line_alpha=0.8,
line_width=0.5)
graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color='#e09e8f',
line_width=3)
graph_renderer.inspection_policy = NodesAndLinkedEdges()
graph_renderer.selection_policy = EdgesAndLinkedNodes()
graph_renderer.node_renderer.data_source.data['hashtag'] = tags
graph_plot.renderers.append(graph_renderer)
output_file("interactive_graphs.html")
show(graph_plot)
def get_graph_renderer(S, line_dash):
# we need a consistent ordering of the edges
edgelist = S.edges()
nodelist = S.nodes()
# get the colors assigned to each edge based on friendly/hostile
sign_edge_color = ['#87DACD' if S[u][v]['sign'] == 1 else '#FC9291' for u, v in edgelist]
# get the colors assigned to each node by coloring
try:
coloring_node_color = ['#4378F8' if nodelist[v]['color'] else '#FFE897' for v in nodelist]
except KeyError:
coloring_node_color = ['#FFFFFF' for __ in nodelist]
graph_renderer = from_networkx(S, layout_wrapper)
circle_size = 10
graph_renderer.node_renderer.data_source.add(coloring_node_color, 'color')
graph_renderer.node_renderer.glyph = Circle(size=circle_size, fill_color='color')
edge_size = 2
graph_renderer.edge_renderer.data_source.add(sign_edge_color, 'color')
try:
graph_renderer.edge_renderer.data_source.add([S[u][v]['event_year'] for u, v in edgelist], 'event_year')
graph_renderer.edge_renderer.data_source.add(
[S[u][v]['event_description'] for u, v in edgelist], 'event_description')
plot.add_tools(HoverTool(tooltips=[("Year", "@event_year"), ("Description", "@event_description")],
line_policy="interp"))
except KeyError:
pass
graph_renderer.edge_renderer.glyph = MultiLine(line_color='color', line_dash=line_dash)
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
return graph_renderer
def show(self):
'''Paint the graph object'''
plot = figure(
plot_width=self.width,
plot_height=self.height,
title=self.title,
x_range=(0, self.width),
y_range=(0, self.height)
)
plot.axis.visible = False
plot.grid.visible = False
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool())
self.define_vertex_shape()
self.define_edges()
self.bokeh_graph.selection_policy = NodesAndLinkedEdges()
self.bokeh_graph.inspection_policy = EdgesAndLinkedNodes()
self.map_to_coordinates()
# print('\nSHAPE', self.bokeh_graph.node_renderer.data_source.data)
# print('\nEDGES', self.bokeh_graph.edge_renderer.data_source.data)
# print('\nCOORDINATES', self.bokeh_graph.layout_provider)
# INCLUDE the Graph in the Plot
plot.renderers.append(self.bokeh_graph)
# GENERATE PLOT HTML FILE AND OPEN IN BROWSER
output_file('./graph.html')
show(plot)
def create_transactor_figure(G):
plot = Plot(plot_width=800,
plot_height=600,
x_range=Range1d(-1.1, 1.1),
y_range=Range1d(-1.1, 1.1))
plot.title.text = "Transactor Visualization"
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool(),
WheelZoomTool(), PanTool())
graph_renderer = from_networkx(G, nx.spring_layout, scale=1, center=(0, 0))
graph_renderer.node_renderer.glyph = Circle(size=4,
fill_color=Spectral4[0])
graph_renderer.node_renderer.selection_glyph = Circle(
size=4, fill_color=Spectral4[2])
graph_renderer.node_renderer.hover_glyph = Circle(size=4,
fill_color=Spectral4[1])
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
line_alpha=0.8,
line_width=3)
graph_renderer.edge_renderer.selection_glyph = MultiLine(
line_color=Spectral4[2], line_width=3)
graph_renderer.edge_renderer.hover_glyph = MultiLine(
line_color=Spectral4[1], line_width=3)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
plot.renderers.append(graph_renderer)
return plot
def draw_graph(plot, G):
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool())
graph = from_networkx(G,
nx.spring_layout,
pos=node_positions,
fixed=node_positions.keys())
graph.node_renderer.glyph = Circle(size=15, fill_color=Spectral4[0])
graph.node_renderer.selection_glyph = Circle(size=15,
fill_color=Spectral4[2])
graph.node_renderer.hover_glyph = Circle(size=15, fill_color=Spectral4[1])
graph.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
line_alpha=0.8,
line_width=5)
graph.edge_renderer.selection_glyph = MultiLine(line_color=Spectral4[2],
line_width=5)
graph.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1],
line_width=5)
graph.selection_policy = NodesAndLinkedEdges()
graph.inspection_policy = EdgesAndLinkedNodes()
plot.renderers.append(graph)
return 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 plot_bokeh_network_i(G,
id,
layout=nx.circular_layout,
output="testing.html"):
plot = Plot(plot_width=400,
plot_height=400,
x_range=Range1d(-1.1, 1.1),
y_range=Range1d(-1.1, 1.1))
plot.title.text = "Graph Interaction Demonstration"
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool(),
WheelZoomTool())
graph_renderer = from_networkx(G, layout, scale=1, center=(0, 0))
graph_renderer.node_renderer.glyph = Circle(size=15,
fill_color=Spectral4[0])
graph_renderer.node_renderer.selection_glyph = Circle(
size=15, fill_color=Spectral4[2])
graph_renderer.node_renderer.hover_glyph = Circle(size=15,
fill_color=Spectral4[1])
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
line_alpha=0.8,
line_width=5)
graph_renderer.edge_renderer.selection_glyph = MultiLine(
line_color=Spectral4[2], line_width=5)
graph_renderer.edge_renderer.hover_glyph = MultiLine(
line_color=Spectral4[1], line_width=5)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
x, y = zip(*graph_renderer.layout_provider.graph_layout.values())
node_labels = nx.get_node_attributes(G, 'hostname')
source = ColumnDataSource({
'x':
x,
'y':
y,
'label': [node_labels[id[i]] for i in range(len(x))]
})
labels = LabelSet(x='x',
y='y',
text='label',
source=source,
background_fill_color='white')
plot.renderers.append(graph_renderer)
output_file(output)
save(plot)
def create_figure(G, ntx):
plot = Plot(plot_width=800,
plot_height=600,
x_range=Range1d(-1.1, 1.1),
y_range=Range1d(-1.1, 1.1))
#plot.title.text = "BTC Block Visualization"
citation = Label(x=0, y=-20, x_units='screen', y_units='screen',
text='This block contains '+str(ntx)+\
' transactions between '+str(len(G.nodes()))+\
' addresses. The most active address transacted with '+str(max(list(dict(G.degree()).values())))+\
' addresses.',
render_mode='css',
border_line_color='red', border_line_alpha=1.0,
background_fill_color='white', background_fill_alpha=1.0)
#citation = Label(x=40, y=0, x_units='screen', y_units='screen',
# text='There were '+str(ntx)+' transactions total. The most active transactor was involved in '+str(max(list(dict(G.degree()).values())))+' transactions.',
# render_mode='css',
# border_line_color='black', border_line_alpha=1.0,
# background_fill_color='white', background_fill_alpha=1.0)
plot.add_layout(citation)
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool(),
WheelZoomTool(), PanTool())
graph_renderer = from_networkx(G,
nx.circular_layout,
scale=1,
center=(0, 0))
graph_renderer.node_renderer.glyph = Circle(size=4,
fill_color=Spectral4[0])
graph_renderer.node_renderer.selection_glyph = Circle(
size=4, fill_color=Spectral4[2])
graph_renderer.node_renderer.hover_glyph = Circle(size=4,
fill_color=Spectral4[1])
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
line_alpha=0.8,
line_width=3)
graph_renderer.edge_renderer.selection_glyph = MultiLine(
line_color=Spectral4[2], line_width=3)
graph_renderer.edge_renderer.hover_glyph = MultiLine(
line_color=Spectral4[1], line_width=3)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
plot.renderers.append(graph_renderer)
return plot
def visualize_self_attention_scores(tokens, scores, filename="/notebooks/embedding/self-attention.png",
use_notebook=False):
mean_prob = np.mean(scores)
weighted_edges = []
for idx_1, token_prob_dist_1 in enumerate(scores):
for idx_2, el in enumerate(token_prob_dist_1):
if idx_1 == idx_2 or el < mean_prob:
weighted_edges.append((tokens[idx_1], tokens[idx_2], 0))
else:
weighted_edges.append((tokens[idx_1], tokens[idx_2], el))
max_prob = np.max([el[2] for el in weighted_edges])
weighted_edges = [(el[0], el[1], (el[2] - mean_prob) / (max_prob - mean_prob)) for el in weighted_edges]
G = nx.Graph()
G.add_nodes_from([el for el in tokens])
G.add_weighted_edges_from(weighted_edges)
plot = Plot(plot_width=500, plot_height=500,
x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1))
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool())
graph_renderer = from_networkx(G, nx.circular_layout, scale=1, center=(0, 0))
graph_renderer.node_renderer.data_source.data['colors'] = Spectral8[:len(tokens)]
graph_renderer.node_renderer.glyph = Circle(size=15, line_color=None, fill_color="colors")
graph_renderer.node_renderer.selection_glyph = Circle(size=15, fill_color="colors")
graph_renderer.node_renderer.hover_glyph = Circle(size=15, fill_color="grey")
graph_renderer.edge_renderer.data_source.data["line_width"] = [G.get_edge_data(a, b)['weight'] * 3 for a, b in
G.edges()]
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC", line_width={'field': 'line_width'})
graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color="grey", line_width=5)
graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color="grey", line_width=5)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
plot.renderers.append(graph_renderer)
x, y = zip(*graph_renderer.layout_provider.graph_layout.values())
data = {'x': list(x), 'y': list(y), 'connectionNames': tokens}
source = ColumnDataSource(data)
labels = LabelSet(x='x', y='y', text='connectionNames', source=source, text_align='center')
plot.renderers.append(labels)
plot.add_tools(SaveTool())
if use_notebook:
output_notebook()
show(plot)
else:
export_png(plot, filename)
print("save @ " + filename)
def show_en_graph(self):
df = self.df
df = df.rename({'user.login':'******'}, axis=1)
issues = list(df.title.unique())
users = list(df.dusers.unique())
plt.figure(figsize=(12, 12))
g = nx.from_pandas_edgelist(df, source='dusers', target='title', edge_attr='dusers')
layout = nx.spring_layout(g,iterations=50)
nx.draw_networkx_edges(g, layout, edge_color='#AAAAAA')
users = [node for node in g.nodes() if node in df.dusers.unique()]
size = [g.degree(node) * 80 for node in g.nodes() if node in df.dusers.unique()]
nx.draw_networkx_nodes(g, layout, nodelist=users, node_size=size, node_color='lightblue')
issues = [node for node in g.nodes() if node in df.title.unique()]
nx.draw_networkx_nodes(g, layout, nodelist=issues, node_size=100, node_color='#AAAAAA')
high_degree_issues = [node for node in g.nodes() if node in df.title.unique() and g.degree(node) > 1]
nx.draw_networkx_nodes(g, layout, nodelist=high_degree_issues, node_size=100, node_color='#fc8d62')
user_dict = dict(zip(users, users))
nx.draw_networkx_labels(g, layout, labels=user_dict)
plt.axis ('off')
plt.title ("Network Graph of Users and the Issues generated")
plt.show()
# Exporting Interactive Graph
TOOLTIPS = [
("name", "@dusers"),
]
plot = Plot(x_range=Range1d(-1.1,1.1), y_range=Range1d(-1.1,1.1))
plot.title.text = "Network Graph of Users and the Issues generated"
plot.add_tools(HoverTool(tooltips=TOOLTIPS), TapTool(), BoxSelectTool(), WheelZoomTool())
graph_renderer = from_networkx(g, nx.spring_layout, scale=1, center=(0,0))
graph_renderer.node_renderer.glyph = Circle(size=15, fill_color=Spectral4[0])
graph_renderer.node_renderer.selection_glyph = Circle(size=15, fill_color=Spectral4[2])
graph_renderer.node_renderer.hover_glyph = Circle(size=15, fill_color=Spectral4[1])
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC", line_alpha=0.8, line_width=5)
graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color=Spectral4[2], line_width=5)
graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1], line_width=5)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
# plot.renderers.append(graph_renderer)
output_file("interactive_graph.html")
show(plot)
def _setup_graph_renderer(self, circle_size):
# The renderer will have the actual logic for drawing
graph_renderer = GraphRenderer()
# Add the vertex data as instructions for drawing nodes\
graph_renderer.node_renderer.data_source.add(
[x.label for x in self.graph.vertices.values()], 'index')
# Nodes will be random colors
self._color_connections(self.graph)
graph_renderer.node_renderer.data_source.add(self._assign_colors(),
'color')
# And circles
graph_renderer.node_renderer.glyph = Circle(size=circle_size,
fill_color='color')
graph_renderer.node_renderer.selection_glyph = Circle(
size=circle_size * 2, fill_color='color')
graph_renderer.node_renderer.hover_glyph = Circle(size=circle_size * 2,
fill_color='color')
# And edges
graph_renderer.edge_renderer.glyph = MultiLine(line_color='color',
line_alpha=0.8,
line_width=2)
graph_renderer.edge_renderer.selection_glyph = MultiLine(
line_color='color', line_width=5)
graph_renderer.edge_renderer.hover_glyph = MultiLine(
line_color='color', line_width=5)
# Add the edge [start, end] indices as instructions for drawing edges
graph_renderer.edge_renderer.data_source.data = self._get_edge_indexes(
)
self._assign_pos() # Randomize vertex coordinates, and set as layout
graph_renderer.layout_provider = StaticLayoutProvider(
graph_layout=self.pos)
# Set 'dem policies, bruh
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
# Attach the prepared renderer to the plot so it can be shown
self.plot.renderers.append(graph_renderer)
self._setup_labels()
nx.set_node_attributes(NFLGraph, 'node_color', node_color)
#we reference the edges
source = ColumnDataSource(
DataFrame.from_dict({k: v
for k, v in NFLGraph.nodes(data=True)},
orient='index'))
#we create the plot
plot = Plot(plot_width=1250,
plot_height=900,
x_range=Range1d(-1.1, 1.1),
y_range=Range1d(-1.1, 1.1))
plot.title.text = "NFL Colleges-Teams Relation"
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool())
graph = from_networkx(NFLGraph, nx.spring_layout, scale=2, center=(0, 0))
graph.node_renderer.data_source = source
graph.node_renderer.glyph = Circle(size='node_size', fill_color='node_color')
graph.node_renderer.selection_glyph = Circle(size='node_size',
fill_color='node_color')
graph.node_renderer.hover_glyph = Circle(size='node_size',
fill_color='node_color')
graph.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[2],
line_width=1)
graph.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
line_alpha=2,
line_width=1)
graph.selection_policy = NodesAndLinkedEdges()
graph.inspection_policy = EdgesAndLinkedNodes()
plot.renderers.append(graph)
output_file("NFL-teams-colleges.html")
show(plot)
def example_func_2():
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 Spectral11, Inferno256, Category20_20
import networkx as nx
from bokeh.models.graphs import from_networkx, NodesAndLinkedEdges, EdgesAndLinkedNodes
from bokeh.models import Plot, Range1d, MultiLine, Circle, HoverTool, TapTool, BoxSelectTool
from bokeh.palettes import Spectral4
# N = 32 # 8
# node_indices = list(range(N))
# print(node_indices)
box_limit = 2 # 1.1
plot = figure(title="Graph Layout Demonstration",
x_range=(-box_limit, box_limit),
y_range=(-box_limit, box_limit))
# tools="", toolbar_location=None)
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool())
# graph = GraphRenderer()
g = nx.karate_club_graph()
N = (len(g.nodes()))
g_layout = nx.spring_layout(g)
graph_layout = g_layout
graph = from_networkx(g, g_layout, scale=2, center=(0, 0))
colors = Category20_20 + Category20_20
node_indices = list(range(N))
graph.node_renderer.data_source.add(node_indices, 'index')
graph.node_renderer.data_source.add(colors, 'color')
graph.node_renderer.glyph = Oval(height=0.1,
width=0.2,
fill_color=Spectral4[0]) # 'color'
graph.node_renderer.selection_glyph = Oval(height=0.1,
width=0.2,
fill_color=Spectral4[1])
graph.node_renderer.hover_glyph = Oval(height=0.1,
width=0.2,
fill_color=Spectral4[2])
graph.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
line_alpha=0.8,
line_width=5)
graph.edge_renderer.selection_glyph = MultiLine(line_color=Spectral4[2],
line_width=5)
graph.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1],
line_width=5)
graph.selection_policy = NodesAndLinkedEdges()
graph.inspection_policy = EdgesAndLinkedNodes()
if True:
if True: # make edges only from node 0 to all others.
graph.edge_renderer.data_source.data = dict(start=[0] * N,
end=node_indices)
if False: # change and make nodes positions on a circle
### 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)
### 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)]
# make run on all nodes. setting edges from [0] node to all others
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("graph2.html")
show(plot)
def Weighted(doc):
args = doc.session_context.request.arguments
file = args.get('file')[0]
file = str(file.decode('UTF-8'))
try:
dfread = pd.read_csv("media/" + file, sep=';')
print('Loaded data succesfully')
except:
raise Exception("File does not exist")
dfSort = dfread.sort_index()
nArr = dfread.index.values
dfArr = dfread.values
nArrSort = dfSort.index.values
nArrSortND = np.asarray(list(dict.fromkeys(nArrSort)))
G = nx.Graph()
for i in range(len(nArrSortND)):
G.add_node(nArrSortND[i])
for x in range(0, len(dfArr) - 1):
xVal = x + 1
for y in range(0, x):
if dfArr[xVal][y] > 0.0:
G.add_edge(nArr[xVal], nArr[y], weight=dfArr[xVal][y])
start_edge = [start_edge for (start_edge, end_edge) in G.edges()]
end_edge = [end_edge for (start_edge, end_edge) in G.edges()]
weight = list(nx.get_edge_attributes(G, 'weight').values())
edge_df = pd.DataFrame({
'source': start_edge,
'target': end_edge,
'weight': weight
})
nodesEdges = list(
dict.fromkeys(
np.append(edge_df['source'].values, edge_df['target'].values)))
nodesEdges.sort()
nodesEdgesSort = np.asarray(nodesEdges)
noEdgesArr = []
noEdgesArrNum = []
for i in range(len(nArrSortND)):
if nArrSortND[i] not in nodesEdgesSort:
noEdgesArr.append(nArrSortND[i])
noEdgesArrNum.append(i)
G.remove_nodes_from(noEdgesArr)
G_source = from_networkx(G, nx.circular_layout, scale=2, center=(0, 0))
graph = GraphRenderer()
# Update loop
def update():
selected_array = []
for i in range(len(edge_df)):
if edge_df['source'][i] == select.value or edge_df['target'][
i] == select.value:
selected_array.append(edge_df.loc[[i]])
selected_df = pd.concat(selected_array)
subArr = selected_df.index.values
subArrVal = selected_df.values
sub_G = nx.Graph()
sub_G.clear()
for i in range(len(nodesEdgesSort)):
sub_G.add_node(nodesEdgesSort[i])
for p in range(len(selected_df)):
sub_G.add_edge(selected_df['source'][subArr[p]],
selected_df['target'][subArr[p]],
weight=selected_df['weight'][subArr[p]])
size = []
alpha = []
weightEdge = []
alpha_hover = []
width = []
edgeName = []
line_color = []
i = 0
k = 0
multiplier = 5 / max(selected_df['weight'])
for p in range(len(nArrSortND)):
if p not in noEdgesArrNum:
if nArrSortND[p] == select.value:
size.append(25)
else:
if nodesEdgesSort[k] in subArrVal:
if selected_df['source'][subArr[i]] == select.value:
alpha.append((sub_G[select.value][
selected_df['target'][subArr[i]]]['weight']) /
(2 / max(selected_df['weight'])))
weightEdge.append(sub_G[select.value][
selected_df['target'][subArr[i]]]['weight'])
alpha_hover.append(1)
width.append(multiplier * sub_G[select.value][
selected_df['target'][subArr[i]]]['weight'])
line_color.append('#FF0000')
edgeName.append([select.value, nodesEdgesSort[k]])
size.append(5 * multiplier * sub_G[select.value][
selected_df['target'][subArr[i]]]['weight'])
else:
alpha.append((sub_G[select.value][
selected_df['source'][subArr[i]]]['weight']) /
(2 / max(selected_df['weight'])))
weightEdge.append(sub_G[select.value][
selected_df['source'][subArr[i]]]['weight'])
alpha_hover.append(1)
width.append(multiplier * sub_G[select.value][
selected_df['source'][subArr[i]]]['weight'])
line_color.append('#FF0000')
edgeName.append([select.value, nodesEdgesSort[k]])
size.append(5 * multiplier * sub_G[select.value][
selected_df['source'][subArr[i]]]['weight'])
i += 1
else:
alpha.append(None)
weightEdge.append(None)
alpha_hover.append(None)
width.append(None)
line_color.append(None)
edgeName.append([select.value, nodesEdgesSort[k]])
size.append(3)
k += 1
sub_graph = from_networkx(sub_G,
nx.circular_layout,
scale=2,
center=(0, 0))
tempnArrSortND1 = nodesEdgesSort[(np.where(
nodesEdgesSort == select.value)[0][0]):]
tempnArrSortND2 = nodesEdgesSort[:(np.where(
nodesEdgesSort == select.value)[0][0])]
newnArrSortND = np.append(tempnArrSortND1, tempnArrSortND2)
nodeSource = ColumnDataSource(data=dict(
size=size,
index=nodesEdgesSort,
))
edgeSource = ColumnDataSource(data=dict(
line_alpha=alpha,
line_weight=weightEdge,
line_alpha_hover=alpha_hover,
line_width=width,
line_color=line_color,
index=edgeName,
start=[select.value] * (len(nodesEdgesSort) - 1),
end=newnArrSortND[1:],
))
sub_graph.edge_renderer.data_source = edgeSource
sub_graph.node_renderer.data_source = nodeSource
graph.edge_renderer.data_source.data = sub_graph.edge_renderer.data_source.data
graph.node_renderer.data_source.data = sub_graph.node_renderer.data_source.data
graph.node_renderer.data_source.add(size, 'size')
def selected_points(attr, old, new):
selected_idx = graph.node_renderer.selected.indices # does not work
print(selected_idx)
select = Select(title='names',
options=nodesEdgesSort.tolist(),
value=nodesEdgesSort[0])
select.on_change('value', lambda attr, old, new: update())
positions = nx.circular_layout(G)
plot = figure(title="Meetup Network Analysis",
x_range=(-1.1, 1.1),
y_range=(-1.1, 1.1),
tools="pan,wheel_zoom,box_select,reset,box_zoom",
plot_width=600,
plot_height=600)
graph.layout_provider = StaticLayoutProvider(graph_layout=positions)
graph.node_renderer.glyph = Circle(size='size', fill_color="#FCFCFC")
graph.node_renderer.selection_glyph = Circle(size='size',
fill_color="#000000")
graph.node_renderer.hover_glyph = Circle(size='size', fill_color="#22A784")
graph.edge_renderer.glyph = MultiLine(line_color='line_color',
line_alpha='line_alpha',
line_width='line_width')
graph.edge_renderer.selection_glyph = MultiLine(
line_color='line_color',
line_alpha='line_alpha_hover',
line_width='line_width')
graph.edge_renderer.hover_glyph = MultiLine(line_color='line_color',
line_alpha='line_alpha_hover',
line_width='line_width')
graph.inspection_policy = NodesAndLinkedEdges() and EdgesAndLinkedNodes()
graph.selection_policy = NodesAndLinkedEdges()
plot.renderers.append(graph)
plot.tools.append(
HoverTool(tooltips=[("index", "@index"), ("weight", "@line_weight")]))
layout = column(select, plot)
graph.node_renderer.data_source.selected.on_change("indices",
selected_points)
doc.add_root(layout)
update()
plot_1 = create_graph(nx.circular_layout,
inspection_policy=NodesAndLinkedEdges(),
scale=1,
center=(0, 0))
plot_1.title.text = "Circular Layout (NodesAndLinkedEdges inspection policy)"
plot_1.add_tools(HoverTool(tooltips=None))
plot_2 = create_graph(nx.spring_layout,
selection_policy=NodesAndLinkedEdges(),
scale=2,
center=(0, 0))
plot_2.title.text = "Spring Layout (NodesAndLinkedEdges selection policy)"
plot_2.add_tools(TapTool(), BoxSelectTool())
plot_3 = create_graph(nx.random_layout,
inspection_policy=EdgesAndLinkedNodes(),
center=(0, 0))
plot_3.title.text = "Random Layout (EdgesAndLinkedNodes inspection policy)"
plot_3.add_tools(HoverTool(tooltips=None))
plot_4 = create_graph(nx.fruchterman_reingold_layout,
selection_policy=EdgesAndLinkedNodes(),
scale=2,
center=(0, 0),
dim=2)
plot_4.title.text = "FR Layout (EdgesAndLinkedNodes selection policy)"
plot_4.add_tools(TapTool())
layout = Column(Row(plot_1, plot_2), Row(plot_3, plot_4))
doc = curdoc()
def mn_display(edges_df, analysis_id):
# create networkx object
G = nx.from_pandas_edgelist(edges_df,
source='cluster1',
target='cluster2',
edge_attr=True)
# convert node attributes
node_dict = dict()
node_dict['index'] = list(G.nodes())
node_attr_keys = [
attr_key for node in list(G.nodes(data=True))
for attr_key in node[1].keys()
]
node_attr_keys = list(set(node_attr_keys))
for attr_key in node_attr_keys:
node_dict[attr_key] = [
node_attr[attr_key] if attr_key in node_attr.keys() else None
for node_key, node_attr in list(G.nodes(data=True))
]
# convert edge attributes
edge_dict = dict()
edge_dict['start'] = [x[0] for x in G.edges(data=True)]
edge_dict['end'] = [x[1] for x in G.edges(data=True)]
edge_attr_keys = [
attr_key for edge in list(G.edges(data=True))
for attr_key in edge[2].keys()
]
edge_attr_keys = list(set(edge_attr_keys))
for attr_key in edge_attr_keys:
edge_dict[attr_key] = [
edge_attr[attr_key] if attr_key in edge_attr.keys() else None
for _, _, edge_attr in list(G.edges(data=True))
]
node_source = ColumnDataSource(data=node_dict)
edge_source = ColumnDataSource(data=edge_dict)
TOOLTIPS = [("cluster1", "@start"), ("score", "@similarity_score"),
("cluster2", "@end")]
plot = Plot(x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1))
plot.add_tools(HoverTool(tooltips=TOOLTIPS), WheelZoomTool(), TapTool(),
BoxSelectTool(), ResetTool(), PanTool(), BoxZoomTool())
# networkx object >> bokeh
graph_renderer = from_networkx(G, nx.spring_layout, scale=1, center=(0, 0))
graph_renderer.node_renderer.data_source.data = node_source.data
graph_renderer.edge_renderer.data_source.data = edge_source.data
# glyphs for nodes
graph_renderer.node_renderer.glyph = Circle(size=15,
fill_color=Spectral6[0])
graph_renderer.node_renderer.selection_glyph = Circle(
size=15, fill_color=Spectral6[2])
graph_renderer.node_renderer.hover_glyph = Circle(size=15,
fill_color=Spectral6[1])
# glyphs for edges
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#cccccc",
line_alpha=0.8,
line_width=3)
graph_renderer.edge_renderer.selection_glyph = MultiLine(
line_color=Spectral6[2], line_width=3)
graph_renderer.edge_renderer.hover_glyph = MultiLine(
line_color=Spectral6[1], line_width=5)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
plot.renderers.append(graph_renderer)
output_file("output.html", title="Analysis {}".format(analysis_id))
show(plot)
resources = INLINE.render()
script, div = components(plot)
return plot, script, div, resources
def bokehgraphmatches(graphtitle, searchterm, mostsimilartuples, terms,
relevantconnections, vtype):
"""
this does not work yet: storing and retrieving the graph requires more work
mostsimilartuples come in a list and look like:
[('ὁμολογέω', 0.8400295972824097), ('θέα', 0.8328431844711304), ('θεά', 0.8282027244567871), ...]
relevantconnections is a dict each of whose keyed entries unpacks into a mostsimilartuples-like list
from_networkx is quite limited
would need to
:param searchterm:
:param mostsimilartuples:
:param vectorspace:
:param searchlist:
:return:
"""
# print('mostsimilartuples:', mostsimilartuples)
# print('terms:', terms)
# print('relevantconnections', relevantconnections)
# the nx part
graph = nx.Graph()
for t in terms:
graph.add_node(t)
for r in relevantconnections:
graph.add_node(r)
edgelist = list()
for t in mostsimilartuples:
edgelist.append((searchterm, t[0], round(t[1] * 10, 2)))
for r in relevantconnections:
for c in relevantconnections[r]:
edgelist.append((r, c[0], round(c[1] * 10, 2)))
graph.add_weighted_edges_from(edgelist)
edgelabels = {(u, v): d['weight'] for u, v, d in graph.edges(data=True)}
pos = nx.fruchterman_reingold_layout(graph)
# colors: https://matplotlib.org/examples/color/colormaps_reference.html
# cmap='tab20c' or 'Pastel1' is nice; lower alpha makes certain others more appealing
scalednodes = [1200 * t[1] * 10 for t in mostsimilartuples]
# nodes
nx.draw_networkx_nodes(graph,
pos,
node_size=scalednodes,
alpha=0.75,
node_color=range(len(terms)),
cmap='Pastel1')
nx.draw_networkx_labels(graph,
pos,
font_size=20,
font_family='sans-serif',
font_color='Black')
# edges
nx.draw_networkx_edges(graph,
pos,
width=3,
alpha=0.85,
edge_color='dimgrey')
nx.draw_networkx_edge_labels(graph,
pos,
edgelabels,
font_size=12,
alpha=0.8,
label_pos=0.5,
font_family='sans-serif')
# the bokeh part
plot = figure(title="Networkx Integration Demonstration",
x_range=(-1.1, 1.1),
y_range=(-1.1, 1.1),
tools="",
toolbar_location=None)
bokehgraph = from_networkx(graph, nx.spring_layout, scale=1, center=(0, 0))
bokehgraph.node_renderer.glyph = Circle(size=15, fill_color=Spectral4[0])
bokehgraph.node_renderer.selection_glyph = Circle(size=15,
fill_color=Spectral4[2])
bokehgraph.node_renderer.hover_glyph = Circle(size=15,
fill_color=Spectral4[1])
bokehgraph.node_renderer.glyph.properties_with_values()
bokehgraph.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
line_alpha=0.8,
line_width=5)
bokehgraph.edge_renderer.selection_glyph = MultiLine(
line_color=Spectral4[2], line_width=5)
bokehgraph.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1],
line_width=5)
bokehgraph.selection_policy = NodesAndLinkedEdges()
bokehgraph.inspection_policy = EdgesAndLinkedNodes()
# broken atm
# source = ColumnDataSource(data=dict(terms=terms))
# labels = LabelSet(x_offset=0, y_offset=0, source=source, render_mode='canvas')
# plot.add_layout(labels)
plot.renderers.append(bokehgraph)
# graphobject = file_html(bokehgraph)
output_file("interactive_graphs.html")
show(plot)
imagename = None
# imagename = storevectorgraph(graphobject)
return imagename
plot_height=400,
x_range=Range1d(-1.1, 1.1),
y_range=Range1d(-1.1, 1.1))
plot.title.text = "Graph Interaction Demonstration"
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool())
graph_renderer = from_networkx(G, nx.circular_layout, scale=1, center=(0, 0))
graph_renderer.node_renderer.glyph = Circle(size=15, fill_color=Spectral4[0])
graph_renderer.node_renderer.selection_glyph = Circle(size=15,
fill_color=Spectral4[2])
graph_renderer.node_renderer.hover_glyph = Circle(size=15,
fill_color=Spectral4[1])
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
line_alpha=0.8,
line_width=5)
graph_renderer.edge_renderer.selection_glyph = MultiLine(
line_color=Spectral4[2], line_width=5)
graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1],
line_width=5)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
plot.renderers.append(graph_renderer)
output_file("interactive_graphs.html")
show(plot)
def max_edges(attrname, old, new):
global prev_chart
global new_network
global tmp
global eligible_edges
global tablePval
global edges_input
global sorte
global pvalcalculated
new_network = nx.DiGraph()
maxs = edges_input.value
print('edge')
total_network= nx.DiGraph()
sorte=sorted(eligible_edges, reverse=True, key=lambda edge:edge[2]['weight'])
z=0
tmp=[]
for from_node,to_node,edge_attributes in sorte:
if z<int(maxs):
tmp.append((from_node, to_node))
z=z+1
print(maxs)
new_network.add_edges_from(tmp)
pos=nx.spring_layout(new_network)
total_network.add_edges_from(eligible_edges)
posTot=nx.spring_layout(total_network)
labels_dict={}
i=1
for j in pos.keys():
labels_dict[j]=i
i=i+1
labels_dict_tot={}
i=1
for j in posTot.keys():
labels_dict_tot[j]=i
i=i+1
df=[]
for i in posTot.keys():
df.append({'x': labels_dict_tot[i], 'y': i})
#----
plot = Plot(plot_width=600, plot_height=500,
x_range=Range1d(-1.1,1.1), y_range=Range1d(-1.1,1.1))
plot.title.text = "Gene network"
plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool())
graph_renderer = from_networkx(new_network, nx.circular_layout, scale=1, center=(0,0))
graph_renderer.node_renderer.glyph = Circle(size=15, fill_color=Spectral4[0])
graph_renderer.node_renderer.selection_glyph = Circle(size=15, fill_color=Spectral4[2])
graph_renderer.node_renderer.hover_glyph = Circle(size=15, fill_color=Spectral4[1])
graph_renderer.node_renderer.glyph.properties_with_values()
graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC", line_alpha=0.8, line_width=5)
graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color=Spectral4[2], line_width=5)
graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1], line_width=5)
graph_renderer.selection_policy = NodesAndLinkedEdges()
graph_renderer.inspection_policy = EdgesAndLinkedNodes()
x, y = zip(*graph_renderer.layout_provider.graph_layout.values())
plot.renderers.append(graph_renderer)
sourceLab = ColumnDataSource({'x': x, 'y': y,
'geneL': [labels_dict[i] for i in pos.keys()]})
labels = LabelSet(x='x', y='y', text='geneL', source=sourceLab,
background_fill_color='white')
sourceDf=ColumnDataSource(data=pd.DataFrame(df))
plot.renderers.append(labels)
columns = [
TableColumn(field="x", title="Label"),
TableColumn(field="y", title="Gene")
]
data_table = DataTable(source=sourceDf, columns=columns, width=400, height=280)
curdoc().remove_root(prev_chart)
if pvalcalculated==False:
calcPvalue()
new_chart=column(ed, row(plot, widgetbox(data_table)), widgetbox(tablePval))
curdoc().add_root(new_chart)
prev_chart=new_chart
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)
