Example #1
0
    def build_graph_renderer(graph, nodes, node_colors, node_sizes,
                             node_scores, node_labels):
        graph_renderer = from_networkx(graph, nx.kamada_kawai_layout)

        graph_renderer.node_renderer.data_source.data['index'] = nodes
        graph_renderer.node_renderer.data_source.data['color'] = node_colors
        graph_renderer.node_renderer.data_source.data['size'] = node_sizes
        graph_renderer.node_renderer.data_source.data[
            'root_score'] = node_scores[0]
        graph_renderer.node_renderer.data_source.data[
            'usage_score'] = node_scores[1]
        graph_renderer.node_renderer.data_source.data['label'] = node_labels

        graph_renderer.node_renderer.glyph = Circle(size="size",
                                                    fill_color="color")
        graph_renderer.node_renderer.selection_glyph = Circle(
            size="size", fill_color="color")
        graph_renderer.node_renderer.hover_glyph = Circle(size="size",
                                                          fill_color="color")

        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 = NodesAndLinkedEdges()

        return graph_renderer
Example #2
0
    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
Example #3
0
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)
Example #4
0
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 NLD_pocessing_graph(g, weights, colors, layout):
    graph = from_networkx(g, layout, scale=1, center=(0, 0))

    # nodes and egdes attributes
    graph.node_renderer.data_source.data['degree'] = list(zip(*g.degree))[1]
    graph.edge_renderer.data_source.data['weight'] = weights
    graph.edge_renderer.data_source.add(colors, 'color')

    graph.node_renderer.glyph = Circle(size='nodesize',
                                       fill_alpha=0.8,
                                       fill_color='royalblue')
    graph.node_renderer.selection_glyph = Circle(size=10,
                                                 fill_alpha=0.8,
                                                 fill_color='red')
    graph.node_renderer.hover_glyph = Circle(size=10,
                                             fill_alpha=0.8,
                                             fill_color='yellow')

    graph.edge_renderer.glyph = MultiLine(line_width=3,
                                          line_alpha=0.8,
                                          line_color='color')
    graph.edge_renderer.selection_glyph = MultiLine(line_width=4,
                                                    line_alpha=0.8,
                                                    line_color='red')
    graph.edge_renderer.hover_glyph = MultiLine(line_width=4,
                                                line_alpha=0.8,
                                                line_color='yellow')
    graph.edge_renderer.glyph.line_width = {'field': 'weight'}

    graph.selection_policy = NodesAndLinkedEdges()
    graph.inspection_policy = NodesAndLinkedEdges()

    return graph
Example #7
0
File: draw.py Project: USP/D-Wave
def circuit_from(bqm):
    G = bqm.to_networkx_graph()
    plot = Plot(plot_width=600, plot_height=400,
                x_range=Range1d(-0.1, 1.1), y_range=Range1d(-.1, 1.1))
    plot.title.text = "Multiplication as a BQM"
    plot.add_tools(HoverTool(tooltips=None), TapTool(), BoxSelectTool())
    graph_renderer = from_networkx(G, circuit_layout)

    circle_size = 25
    graph_renderer.node_renderer.glyph = Circle(
        size=circle_size, fill_color="#F5F7FB")
    graph_renderer.node_renderer.selection_glyph = Circle(size=circle_size, fill_color="#EEA64E")
    graph_renderer.node_renderer.hover_glyph = Circle(size=circle_size, fill_color="#FFE86C")

    edge_size = 2
    graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC", line_alpha=0.8, line_width=edge_size)
    graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color="#EEA64E", line_width=edge_size)
    graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color="#FFE86C", line_width=edge_size)

    graph_renderer.selection_policy = NodesAndLinkedEdges()
    graph_renderer.inspection_policy = NodesAndLinkedEdges()

    plot.renderers.append(graph_renderer)

    plot.background_fill_color = "#202239"

    add_labels(plot)
    show(Row(plot))
Example #8
0
    def define_edges(self):
        start = []
        end = []
        for key in self.vertices:

            # Make a copy of the edges in roder to preserve the integrity of
            # the Graph
            connected_nodes = self.graph.vertices[str(key)].copy()

            # If there are Edges for the current looped Vertex
            if len(connected_nodes):
                for i in range(len(connected_nodes)):
                    start.append(key)  # Add node
                    end.append(int(connected_nodes.pop()))  # Add related edge
            #     print(start)
            #     print(end)
            # print(self.graph.vertices[str(key)])

        color = ['#111111']*len(start)
        self.bokeh_graph.edge_renderer.data_source.data = dict(
            start=start, end=end,
        )
        self.bokeh_graph.edge_renderer.glyph = MultiLine(
            line_color="#CCCCCC", line_alpha=0.8, line_width=1)
        self.bokeh_graph.edge_renderer.selection_glyph = MultiLine(
            line_color=Spectral4[2], line_width=3)
        self.bokeh_graph.edge_renderer.hover_glyph = MultiLine(
            line_color=Spectral4[1], line_width=3)
        print(self.bokeh_graph.edge_renderer.data_source.data.keys())
Example #9
0
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 plot_subgraph(  onto_graph:nx.Graph, node_subset:Union[List[str],Set[str]],
                    in_IPython:bool=False):
    """
    """
    G = onto_graph.subgraph(node_subset)
    # Show with Bokeh
    plot = Plot(plot_width=1600, plot_height=800,
                x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1))

    plot.title.text = "Graph Interaction Demonstration"

    node_hover_tool = HoverTool(tooltips=[("index", "@index"), ("club", "@club")])
    plot.add_tools(node_hover_tool, BoxZoomTool(), ResetTool(), TapTool(), BoxSelectTool(), PanTool())

    graph_renderer = from_networkx(G, nx.kamada_kawai_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_alpha=0.8, line_width=1)
    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")
    if in_IPython: output_notebook()

    show(plot)
Example #11
0
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)
Example #12
0
def create_graph(layout_func,
                 inspection_policy=None,
                 selection_policy=None,
                 **kwargs):

    plot = Plot(width=400,
                height=400,
                x_range=Range1d(-1.1, 1.1),
                y_range=Range1d(-1.1, 1.1))
    graph_renderer = from_networkx(G, layout_func, **kwargs)

    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)

    if inspection_policy is not None:
        graph_renderer.inspection_policy = inspection_policy
    if selection_policy is not None:
        graph_renderer.selection_policy = selection_policy

    plot.renderers.append(graph_renderer)

    return plot
Example #13
0
def NLD_FD_pocessing_graph(g, weights, colors):
    degree_sequence = sorted([d for n, d in g.degree()], reverse=True)

    magicnumber = (g.number_of_nodes() / degree_sequence[0]**2)
    r = 2.2 / magicnumber
    my_points = nx.fruchterman_reingold_layout(g, k=r, iterations=100)

    graph_fd = from_networkx(g, my_points)

    #posxy=nx.fruchterman_reingold_layout(g)
    #for i in range(len(posxy()):
    #    posxy
    #radii = np.random.random(size=N) * 1.5
    my_colors = []
    for key, value in my_points.items():
        x = value[0] + 1.0  # x = -1 .. +1, so move to 0 ... 2
        y = value[1] + 1.0  # y = -1 .. +1, so move to 0 ... 2
        my_colors.append("#%02x%02x%02x" %
                         (int(50 + 100 * x), int(30 + 100 * y), 150))

    # nodes and egdes attributes
    graph_fd.node_renderer.data_source.data['degree'] = list(zip(*g.degree))[1]
    graph_fd.node_renderer.data_source.data['degree2'] = [
        sqrt(x + 6) for x in graph_fd.node_renderer.data_source.data['degree']
    ]
    graph_fd.node_renderer.data_source.data['nodessize'] = [
        x * 115 / (sqrt(g.number_of_nodes() + (np.mean(degree_sequence))))
        for x in graph_fd.node_renderer.data_source.data['degree2']
    ]

    graph_fd.node_renderer.data_source.data['my_fill_color'] = my_colors
    graph_fd.edge_renderer.data_source.data['weight'] = weights
    graph_fd.edge_renderer.data_source.add(colors, 'color')

    graph_fd.node_renderer.glyph = Circle(size="nodesize",
                                          fill_color='my_fill_color',
                                          fill_alpha=0.85)
    graph_fd.node_renderer.selection_glyph = Circle(size=15,
                                                    fill_alpha=0.8,
                                                    fill_color='red')
    graph_fd.node_renderer.hover_glyph = Circle(size=15,
                                                fill_alpha=0.8,
                                                fill_color='yellow')

    graph_fd.edge_renderer.glyph = MultiLine(line_width=2.5,
                                             line_alpha=0.8,
                                             line_color='color')
    graph_fd.edge_renderer.selection_glyph = MultiLine(line_width=2.5,
                                                       line_alpha=0.8,
                                                       line_color='red')
    graph_fd.edge_renderer.hover_glyph = MultiLine(line_width=2.5,
                                                   line_alpha=0.8,
                                                   line_color='yellow')
    graph_fd.edge_renderer.glyph.line_width = {'field': 'weight'}

    graph_fd.selection_policy = NodesAndLinkedEdges()
    graph_fd.inspection_policy = NodesAndLinkedEdges()

    return graph_fd
Example #14
0
def graphNetwork(adjm, data):
    G = nx.from_numpy_matrix(adjm)
    data['degree'] = list(dict(G.degree).values())
    subgraphs = getSubgraphs(G)
    subgraphs = data.join(subgraphs.set_index('nodes'))
    subgraphs['subsets'] = adjm.sum(axis=0)

    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\t Total subgraphs:%i" % (
        G.number_of_nodes(), G.number_of_edges(),
        len(subgraphs.subgraph.unique()))

    node_hover_tool = HoverTool(
        tooltips=[("hashtag",
                   "@hashtag"), ("freq", "@frequency"), (
                       'degree',
                       '@degree'), ('subsets',
                                    '@subsets'), ('subgraph',
                                                  '@subgraph'), ('ix', '@ix')])
    graph_plot.add_tools(node_hover_tool, BoxZoomTool(), ResetTool(),
                         WheelZoomTool())

    graph_renderer = from_networkx(G, nx.spring_layout, scale=1, center=(0, 0))
    graph_renderer.node_renderer.glyph = Circle(size=18, fill_color='#277bb6')
    graph_renderer.node_renderer.hover_glyph = Circle(size=18,
                                                      fill_color='#E84A5F')
    graph_renderer.node_renderer.glyph.properties_with_values()
    graph_renderer.edge_renderer.glyph = MultiLine(line_color="gray",
                                                   line_alpha=0.7,
                                                   line_width=0.3)
    graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color='#e09e8f',
                                                         line_width=3)
    graph_renderer.node_renderer.data_source.data[
        'hashtag'] = subgraphs.ht.values
    graph_renderer.node_renderer.data_source.data[
        'frequency'] = subgraphs.frq.values
    graph_renderer.node_renderer.data_source.data[
        'degree'] = subgraphs.degree.values
    graph_renderer.node_renderer.data_source.data[
        'subgraph'] = subgraphs.subgraph.values
    graph_renderer.node_renderer.data_source.data['ix'] = list(subgraphs.index)
    graph_renderer.node_renderer.data_source.data[
        'subsets'] = subgraphs.subsets.values

    graph_renderer.inspection_policy = NodesAndLinkedEdges()
    graph_renderer.selection_policy = NodesAndLinkedEdges()
    graph_plot.toolbar.active_inspect = [node_hover_tool]
    graph_plot.renderers.append(graph_renderer)

    #output_file(path+topic+"_graph_N"+str(nodeThresh)+'E'+str(edgeThresh)+".html")

    show(graph_plot)

    subgraphs = subgraphs.sort_values(by='subgraph')
    return subgraphs
Example #15
0
def make_plottable(colors=None, sizes=None, tweets=None):
    global NETWORK
    if not NETWORK:
        NETWORK = reload_json(USER_GRAPH_FNAME,
                              nx.DiGraph,
                              transform=nx.node_link_graph)
    graph = from_networkx(NETWORK, graphviz_layout, prog="sfdp")

    if not colors:
        node_color = Spectral4[0]
    else:
        node_color = "color"
        graph.node_renderer.data_source.add(colors, "color")

    if not sizes:
        node_size = 8
    else:
        node_size = "size"
        graph.node_renderer.data_source.add(sizes, "size")

    if tweets:
        graph.node_renderer.data_source.add(tweets, "desc")

    edge_width = 0.3
    select_edge_width = 2
    node_alpha = 0.95
    edge_alpha = 0.3
    edge_color = "#666666"
    select_color = Spectral4[2]
    hover_color = Spectral4[1]

    graph.node_renderer.glyph = Circle(
        size=node_size,
        fill_color=node_color,
        fill_alpha=node_alpha,
        line_color=node_color,
        line_alpha=node_alpha,
    )
    graph.node_renderer.selection_glyph = Circle(size=node_size,
                                                 fill_color=select_color,
                                                 line_color=select_color)
    graph.node_renderer.hover_glyph = Circle(size=node_size,
                                             fill_color=hover_color,
                                             line_color=hover_color)

    graph.edge_renderer.glyph = MultiLine(line_color=edge_color,
                                          line_alpha=edge_alpha,
                                          line_width=edge_width)
    graph.edge_renderer.selection_glyph = MultiLine(
        line_color=select_color, line_width=select_edge_width)
    graph.edge_renderer.hover_glyph = MultiLine(line_color=hover_color,
                                                line_width=select_edge_width)
    graph.selection_policy = NodesAndLinkedEdges()
    graph.inspection_policy = NodesAndLinkedEdges()

    return graph
Example #16
0
    def drawgraph(self, ds, filterMin, filterMax, layout):
        G = nx.Graph()  # create an empty graph with no nodes and no edges

        # nodes = []
        # for i in range(len(ds.getNodes())):
        #     nodes.append([])
        #     # print(ds.getNodes()[i].getName())
        #     for j in range(len(ds.getNodes())):
        #         nodes[i].append(ds.getNodes()[i].getLinks()[j][1])
        #         # print("   " + str(ds.getNodes()[i].getLinks()[j][1]))

        # ds.toMinSpanTree()
        nodes = ds.getDoubleList(filterMin, filterMax, False)

        x = filterMin

        adj = np.array(nodes)
        G = nx.from_numpy_matrix(adj)

        for i in range(len(G.node)):
            G.node[i]['name'] = ds.getNames()[i]
        #pos = nx.drawing.layout.circular_layout(G, 1, None, 2)

        #nx.draw_networkx(G, pos, with_labels=True)
        # pt.show()
        #plt.show()
        plot = Plot(plot_width=500, plot_height=500,
                    x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1))

        node_hover_tool = HoverTool(tooltips=[("Name of this node", "@name")])

        # plot.add_tools(node_hover_tool, BoxZoomTool(), ResetTool())
        plot.add_tools(node_hover_tool, TapTool(), BoxSelectTool(), BoxZoomTool(), UndoTool(), RedoTool(), SaveTool(),
                       ResetTool())
        plot.toolbar_location = 'left'
        if layout == 0:
            graph_renderer = from_networkx(G, nx.circular_layout, scale=1, center=(0, 0))
        elif layout == 1:
            graph_renderer = from_networkx(G, nx.spring_layout, scale=1, center=(0, 0))
        else:
            graph_renderer = from_networkx(G, nx.random_layout)
        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")
        return plot
Example #17
0
def NLD_random_processing_graph(g, weights, colors, layout):
    degree_sequence = sorted([d for n, d in g.degree()], reverse=True)

    magicnumber = (g.number_of_nodes() / degree_sequence[0]**2)
    r = 2.2 / magicnumber
    my_points = nx.random_layout(g)

    graph = from_networkx(g, layout)

    my_colors = []
    for key, value in my_points.items():
        x = value[0] + 1.0  # x = -1 .. +1, so move to 0 ... 2
        y = value[1] + 1.0  # y = -1 .. +1, so move to 0 ... 2
        my_colors.append("#%02x%02x%02x" %
                         (int(50 + 100 * x), int(30 + 100 * y), 150))

    # nodes and egdes attributes
    graph.node_renderer.data_source.data['degree'] = list(zip(*g.degree))[1]
    graph.node_renderer.data_source.data['degree2'] = [
        sqrt(x + 6) for x in graph.node_renderer.data_source.data['degree']
    ]
    graph.node_renderer.data_source.data['nodessize'] = [
        x * 115 / (sqrt(g.number_of_nodes() + (np.mean(degree_sequence))))
        for x in graph.node_renderer.data_source.data['degree2']
    ]

    graph.node_renderer.data_source.data['my_fill_color'] = my_colors
    graph.edge_renderer.data_source.data['weight'] = weights
    graph.edge_renderer.data_source.add(colors, 'color')

    graph.node_renderer.glyph = Circle(size='nodesize',
                                       fill_alpha=0.85,
                                       fill_color='my_fill_color')
    graph.node_renderer.selection_glyph = Circle(size=10,
                                                 fill_alpha=0.8,
                                                 fill_color='red')
    graph.node_renderer.hover_glyph = Circle(size=10,
                                             fill_alpha=0.8,
                                             fill_color='yellow')

    graph.edge_renderer.glyph = MultiLine(line_width=3,
                                          line_alpha=0.8,
                                          line_color='color')
    graph.edge_renderer.selection_glyph = MultiLine(line_width=4,
                                                    line_alpha=0.8,
                                                    line_color='red')
    graph.edge_renderer.hover_glyph = MultiLine(line_width=4,
                                                line_alpha=0.8,
                                                line_color='yellow')
    graph.edge_renderer.glyph.line_width = {'field': 'weight'}

    graph.selection_policy = NodesAndLinkedEdges()
    graph.inspection_policy = NodesAndLinkedEdges()

    return graph
Example #18
0
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)
Example #19
0
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
Example #20
0
def visual():
    '''
    visualze whole graph
    '''
    nx = networkx.Graph()
    color_movie = Spectral4[0]
    color_actor = Spectral4[3]

    for aid in g.all_actors:
        inf = g.all_actors[aid]['age']
        nx.add_node(aid, type = 'Actor', item_name = aid, info = "Age: " + str(inf), color = color_actor, size = 10)


    for mid in g.all_movies:
        # if g.all_movies[mid]['actors'] == []:
        #     continue
        inf = g.all_movies[mid]['box_office']
        nx.add_node(mid, type = 'Movie', item_name = mid,info = "Box Office: " + str(inf), color = color_movie, size = 15)

    for mid in g.all_movies:
        movie = g.all_movies[mid]
        for aid in movie['actors']:
            if aid not in g.all_actors:
                continue
            nx.add_edge(mid, aid)

    for aid in g.all_actors:
        for mid in g.all_actors[aid]['movies']:
            if mid not in g.all_movies:
                continue
            nx.add_edge(aid, mid)


    p = Plot(plot_width=1200, plot_height=1200,
                x_range=Range1d(-3, 3), y_range=Range1d(-3, 3))
    p.title.text = "Visualization of the graph"
    p.add_tools(HoverTool(tooltips=[("Name", "@item_name"), ("Info", "@info")]), TapTool(), BoxSelectTool())

    graph_renderer = from_networkx(nx, networkx.spring_layout, scale=7, center=(0, 0))
    graph_renderer.node_renderer.glyph = Circle(size='size', fill_color='color')
    graph_renderer.node_renderer.selection_glyph = Circle(size='size', fill_color=Spectral4[2])
    graph_renderer.node_renderer.hover_glyph = Circle(size='size', fill_color=Spectral4[1])

    graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC", line_alpha=0.8, line_width=1)
    graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color='#440154', line_width=1)
    graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1], line_width=1)

    graph_renderer.selection_policy = NodesAndLinkedEdges()
    graph_renderer.inspection_policy = NodesOnly()
    p.renderers.append(graph_renderer)
    script, div = components(p)
    return render_template("visualization.html", script=script, div=div)
Example #21
0
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)
Example #22
0
    def get_bokeh_plot(self):
        """Get a nice Bokeh plot of the network."""
        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 = "Agents network"

        plot.add_tools(
            HoverTool(tooltips=[("AgentID", "@index")]),
            TapTool(),
            )

        graph_renderer = from_networkx(
            self.graph,
            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=3,
            )
        graph_renderer.edge_renderer.selection_glyph = MultiLine(
            line_color=Spectral4[2],
            line_width=3,
            )

        graph_renderer.selection_policy = NodesAndLinkedEdges()
        graph_renderer.inspection_policy = NodesOnly()

        plot.renderers.append(graph_renderer)
        return plot
Example #23
0
	def network_total_following(self, user_dict, n_neighbors=5):
		graph = nx.Graph()
		self.add_nodes(graph, user_dict)
		self.add_edges(graph, user_dict)
		for node in list(graph.nodes()):
			if len(list(graph.neighbors(node))) < n_neighbors:
				graph.remove_node(node)
		plot = Plot(
			plot_width=1140,
			plot_height=720,
			x_range=Range1d(-1.1,1.1),
			y_range=Range1d(-1.1,1.1))
		plot.add_tools(
			HoverTool(tooltips=[('User','@name'),
				('Neighbors', '@neighbors')],
				line_policy='nearest'),
			TapTool(),
			BoxSelectTool(),
			PanTool(),
			WheelZoomTool(),
			ResetTool())
		graph_render = from_networkx(graph, nx.spring_layout, scale=2.5, center=(0,0))
		graph_render.node_renderer.data_source.data['name'] = list(graph.nodes())
		list_edges = self.get_list_of_edges(graph)
		graph_render.node_renderer.data_source.data['neighbors'] = list_edges
		mapper = linear_cmap('neighbors', palette=Plasma11, low=min(list_edges), high=max(list_edges))
		graph_render.node_renderer.glyph = Circle(
			size=10,
			fill_color=mapper)
		graph_render.node_renderer.hover_glyph = Circle(
			size=200,
			fill_color=mapper)
		graph_render.node_renderer.selection_glyph = Circle(
			size=200,
			fill_color=mapper)
		graph_render.edge_renderer.glyph = MultiLine(
			line_color=Greys4[2],
			line_alpha=0.3,
			line_width=1)
		graph_render.edge_renderer.hover_glyph = MultiLine(
			line_color=Greys4[1],
			line_width=2)
		graph_render.edge_renderer.selection_glyph = MultiLine(
			line_color=Greys4[0],
			line_width=3)
		graph_render.selection_policy = NodesAndLinkedEdges()
		graph_render.inspection_policy = NodesAndLinkedEdges()
		plot.renderers.append(graph_render)
		show(plot)
Example #24
0
    def plot_create(self, doc):
        plot = figure(title="Belief Graph")
        plot.axis.visible = False

        node_labels = nx.get_node_attributes(self.bel_graph, 'id')
        node_labels = tuple([label for label in node_labels.values()])

        ncolor = ['#2b83ba' for name in node_labels]
        nsize = [15 for name in node_labels]

        graph = from_networkx(self.bel_graph,
                              nx.spring_layout,
                              scale=1,
                              center=(0, 0))

        graph.node_renderer.glyph = Circle(size='nsize', fill_color='ncolor')
        graph.node_renderer.selection_glyph = Circle(size='nsize',
                                                     fill_color='#054872')
        graph.node_renderer.hover_glyph = Circle(size='nsize',
                                                 fill_color='#abdda4')
        graph.name = "bel_graph"

        graph.node_renderer.data_source.data.update(
            dict(id=node_labels, ncolor=ncolor, nsize=nsize))

        graph.edge_renderer.glyph = MultiLine(line_color="#CCCCCC",
                                              line_alpha=0.8,
                                              line_width=5)
        graph.edge_renderer.selection_glyph = MultiLine(line_color='#054872',
                                                        line_width=5)
        graph.edge_renderer.hover_glyph = MultiLine(line_color='#abdda4',
                                                    line_width=5)

        graph.selection_policy = NodesAndLinkedEdges()
        # graph.inspection_policy = EdgesAndLinkedNodes()

        plot.renderers.append(graph)

        x, y = zip(*graph.layout_provider.graph_layout.values())

        source_graph = ColumnDataSource(data=dict(x=x, y=y, id=node_labels))
        labels = LabelSet(x='x', y='y', text='id', source=source_graph)

        plot.renderers.append(labels)

        # add tools to the plot
        plot.add_tools(HoverTool(names=["bel_graph"]), TapTool())

        doc.add_root(plot)
Example #25
0
def plotGraph(graph, title=None, graphSavePath=None, networkPath=None):
    for k, adjacencies in zip(list(graph.nodes.keys()), graph.adjacency()):
        graph.nodes[k]["degree"] = len(adjacencies[1])
    if networkPath is not None:
        for city in graph.nodes():
            graph.nodes[city]["code"] = graph.networkPath.stationList.getCode(
                city)
    plot_height = 700
    plot = Plot(plot_width=900,
                plot_height=plot_height,
                x_range=Range1d(-1.1, 1.1),
                y_range=Range1d(-1.1, 1.1))
    plot.title.text = title
    node_hover_tool = HoverTool(
        tooltips=[("Miasto",
                   "@index"), ("Kod miasta",
                               "@code"), ("Stopien wierzcholka", "@degree")])
    plot.add_tools(WheelZoomTool(), PanTool(), SaveTool(), node_hover_tool,
                   BoxZoomTool(), ResetTool())  # , TapTool())
    graph_renderer = from_networkx(graph,
                                   nx.spring_layout,
                                   scale=1,
                                   center=(0, 0))
    graph_renderer.node_renderer.glyph = Circle(size=12, fill_color="yellow")
    graph_renderer.node_renderer.selection_glyph = Circle(size=15,
                                                          fill_color="blue")
    graph_renderer.node_renderer.hover_glyph = Circle(size=15,
                                                      fill_color="red")
    graph_renderer.edge_renderer.glyph = MultiLine(line_color="green",
                                                   line_alpha=0.3,
                                                   line_width=1)
    graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color="blue",
                                                             line_width=1.2)
    graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color="red",
                                                         line_width=1.2)
    plot.renderers.append(graph_renderer)
    columnCities = ColumnDataSource(data=dict(city=list(graph.nodes.keys())))
    columnsNetwork = [
        TableColumn(field="city", title="Miasto"),
    ]
    table = DataTable(source=columnCities,
                      columns=columnsNetwork,
                      width=155,
                      height=plot_height)
    layout = row(plot, table)
    if graphSavePath is not None:
        output_file(graphSavePath, title)
    show(layout)
Example #26
0
    def modify_doc(doc):
        plot = Plot(height=400,
                    width=400,
                    x_range=Range1d(0, 3),
                    y_range=Range1d(0, 3),
                    min_border=0)
        renderer = plot.add_glyph(source, MultiLine(xs='xs', ys='ys'))
        tool = PolyEditTool(renderers=[renderer])
        psource = ColumnDataSource(dict(x=[], y=[]))
        prenderer = plot.add_glyph(psource, Circle(x='x', y='y', size=10))
        tool.vertex_renderer = prenderer
        plot.add_tools(tool)
        plot.toolbar.active_multi = tool
        plot.toolbar_sticky = False
        div = Div(text='False')

        def cb(attr, old, new):
            try:
                if cds_data_almost_equal(new, expected):
                    div.text = 'True'
            except ValueError:
                return

        source.on_change('data', cb)
        code = RECORD("matches", "div.text")
        plot.add_tools(
            CustomAction(callback=CustomJS(args=dict(div=div), code=code)))
        doc.add_root(column(plot, div))
Example #27
0
def test_graphrenderer_check_malformed_graph_source_no_edge_start_or_end():
    edge_source = ColumnDataSource()
    edge_renderer = GlyphRenderer(data_source=edge_source, glyph=MultiLine())
    renderer = GraphRenderer(edge_renderer=edge_renderer)

    check = renderer._check_malformed_graph_source()
    assert check != []
Example #28
0
def bokeh(G, node_color=None, node_label=None, node_size=100, node_size_scale=[25,200], alpha=0.8, font_size=18, cmap='Set1', width=40, height=30, pos=None, filename=None, title=None, methodtype='default', verbose=3):
    import networkx as nx
    from bokeh.io import show, output_file
    from bokeh.models import Plot, Range1d, MultiLine, Circle, HoverTool, BoxZoomTool, ResetTool
    from bokeh.models.graphs import from_networkx
    from bokeh.palettes import Spectral4
    
    SAME_CLUB_COLOR, DIFFERENT_CLUB_COLOR = "black", "red"
    edge_attrs = {}
    
    for start_node, end_node, _ in G.edges(data=True):
        edge_color = SAME_CLUB_COLOR if G.nodes[start_node]["club"] == G.nodes[end_node]["club"] else DIFFERENT_CLUB_COLOR
        edge_attrs[(start_node, end_node)] = edge_color
    
    nx.set_edge_attributes(G, edge_attrs, "edge_color")
    
    # Show with Bokeh
    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"
    
    node_hover_tool = HoverTool(tooltips=[("index", "@index"), ("club", "@club")])
    plot.add_tools(node_hover_tool, BoxZoomTool(), ResetTool())
    
    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.edge_renderer.glyph = MultiLine(line_color="edge_color", line_alpha=0.8, line_width=1)
    plot.renderers.append(graph_renderer)
    
    output_file("interactive_graphs.html")
    show(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
Example #30
0
def plotNetXBokeh(src_abv,src_belw,q_csid):
    max_XNodeVal = max(src_belw['xs_node'])
    max_YNodeVal = max(src_belw['ys_node'])
    buffer = 0.1
    plot = figure(sizing_mode='scale_width',x_range=(-max_XNodeVal-buffer, max_XNodeVal+buffer),y_range=(-max_YNodeVal-buffer, max_YNodeVal+buffer))
    plot.outline_line_color = None
    source_belw = ColumnDataSource(src_belw)
    source_abv = ColumnDataSource(src_abv)
    glyph = MultiLine(xs="xs_line", ys="ys_line", line_color='lcolour', line_width='weight',line_alpha='alpha')
    plot.add_glyph(source_belw, glyph)
    plot.add_glyph(source_abv, glyph) #add the above threshold lines last so it overlays the below lines
    plot.circle('xs_node', 'ys_node', source=source_belw, size='size', color='colour',line_color='#020c15',line_width=0.5,name='showhover')
    plot.circle('xs_node', 'ys_node', source=source_abv, size='size', color='colour',line_color='#020c15',line_width=0.5,name='showhover')
    dictHoverLabels = {'CSID':'csid','Name':'cname','EucliDist':'euclidist'}
    node_hover_tool = customHoverTool(dictHoverLabels,400)
    # node_hover_tool = hover = HoverTool(names=['showhover'], tooltips="""
    #     <div style="word-wrap: break-word; width: 400px;">
    #         <p><span style="font-size: 5; font-weight: bold;">CSID: @csid</span><p>
    #         <p><span style="font-size: 5; font-weight: bold;">Name: @cname</span><p>
    #         <p><span style="font-size: 5; font-weight: bold;">EucliDist: @euclidist</span><p>
    #     </div>
    #           """)
    plot.add_tools(node_hover_tool)
    plot.toolbar.logo = None
    plot.min_border = 0
    plot.axis.visible = False
    plot.toolbar.autohide = True 
    plot.grid.visible = False
    return plot