def do_draw(self, line):
        g = self.graph

        spectral = plt.get_cmap('spectral')
        n_levels = len(types)
        val = 0.0
        step = 1.0 / n_levels
        colors = {}
        for k in types.keys():
            colors[k] = spectral(val)
            val += step
        g.vp.v_colors = g.new_vp('vector<float>')
        for v in g.vertices():
            g.vp.v_colors[v] = colors[g.vp.type[v]]

        if line:
            gt_draw.graph_draw(self.graph,
                               pos=gt_draw.arf_layout(g),
                               output_size=(2400,2400),
                               vertex_text=g.vp.type,
                               vertex_fill_color=g.vp.v_colors,
                               vertex_size=10,
                               output=line)
        else:
            gt_draw.interactive_window(self.graph,
                                       vertex_fill_color=g.vp.v_colors,
                                       vertex_size=10,
                                       display_props=[g.vp.type,
                                                      g.vp.data,
                                                      g.vp.pool,
                                                      g.vp.unit ])
def show_spec_in_graph(graph, vertex, spec, pos, weight, file_name):
    dist = 1.0 - squareform(pdist(spec.T, 'cosine'))

    plt.figure()
    plt.stem(dist[vertex, :], markerfmt=' ')

    rim = graph.new_vertex_property('vector<double>')
    rim.set_2d_array(np.array([0, 0, 0, 1]))
    rim[graph.vertex(vertex)] = [0.8941176471, 0.1019607843, 0.1098039216, 1]
    rim_width = graph.new_vertex_property('float', vals=0.5)
    rim_width.a[vertex] = 2
    shape = graph.new_vertex_property('int', vals=0)
    shape[graph.vertex(vertex)] = 2
    size = graph.new_vertex_property('double', vals=10)
    size.a[vertex] = 15
    correlation = graph.new_vertex_property('double', vals=2)
    correlation.a = dist[vertex, :]
    vorder = graph.new_vertex_property('int', vals=0)
    vorder.a[vertex] = 1

    palette = sns.cubehelix_palette(256)
    cmap = colors.ListedColormap(palette)
    gt_draw.graph_draw(graph, pos=pos, vertex_color=rim, vorder=vorder,
                       vertex_pen_width=rim_width,
                       vertex_shape=shape, vertex_fill_color=correlation,
                       vcmap=cmap, vertex_size=size, edge_color=[0, 0, 0, 0.7],
                       edge_pen_width=weight, output=file_name + '.png',
                       output_size=(1200, 1200))

    plt.figure()
    utils.plot_colorbar(cmap, np.arange(0, 1.01, 0.2), file_name)
Beispiel #3
0
def intranode_distance():
    #choose a random leaf
    print('process the graph')
    elected = soma
    while elected.out_degree() != 0:
        elected = random.choice(list(tree.vertices()))
    #measure distance for all the resting leaves
    for node in tree.vertices():
        if node.out_degree() == 0:
            distanceNode[node] = distance(name[elected], name[node])
        else:
            distanceNode[node] = 1
    #diffuse tubuline demand proportional respect the elected leaf distance
    tubuline.a = 2**(0.01 * distanceNode.a)
    cent_order.a = 1000 / (cent_order.a + 1)
    size = draw.prop_to_size(cent_order)
    #plot it to understand
    pos = draw.sfdp_layout(tree)
    draw.graph_draw(tree,
                    pos=pos,
                    vertex_fill_color=tubuline,
                    vertex_size=size)
    draw.graph_draw(tree,
                    pos=pos,
                    vertex_fill_color=tubuline,
                    vertex_text=distanceNode)
Beispiel #4
0
def balancedBinaryTree(h, drawGraph=False):
    '''
    h - the height of the tree
    '''
    g = Graph(directed=False)
    g.add_vertex(2**h - 1)

    for i in xrange(1, 2**(h - 1)):
        lc = 2 * i - 1
        rc = lc + 1
        g.add_edge(i - 1, lc)
        g.add_edge(i - 1, rc)

    hIndex = g.new_vertex_property(
        "int")  #associate with each node the height at which it lies
    k = 2
    m = 1
    for i in xrange(1, len(hIndex.a)):
        hIndex.a[i] = m
        k -= 1
        if k == 0:
            m += 1
            k = 2**m
    g.vp['height'] = hIndex

    if drawGraph == True:
        draw.graph_draw(g,
                        vertex_text=g.vertex_index,
                        edge_color="black",
                        output="binaryTree_h_" + str(h) + "_.pdf")

    return g
Beispiel #5
0
def plot(graph, weights, pos, station_values, name):
    palette = sns.color_palette('RdBu', n_colors=256)
    cmap = colors.ListedColormap(palette[::-1])

    weights = weights.copy()
    weights.a -= np.min(weights.a)
    weights.a *= 2 / np.max(weights.a)
    weights.a += 0.2

    gt_draw.graph_draw(graph, pos=pos, vertex_color=[0, 0, 0, 0.5],
                       vertex_fill_color=station_values, vcmap=cmap,
                       vertex_size=5, edge_color=[0, 0, 0, 0.7],
                       edge_pen_width=weights,
                       output=name + '_temp.svg')
    gt_draw.graph_draw(graph, pos=pos, vertex_color=[0, 0, 0, 0.5],
                       vertex_fill_color=station_values, vcmap=cmap,
                       vertex_size=10, edge_color=[0, 0, 0, 0.7],
                       edge_pen_width=weights,
                       output=name + '_temp.png', output_size=(1200, 1200))

    min_val = np.min(station_values.a)
    max_val = np.max(station_values.a)
    step = (max_val - min_val) / 5
    labels = np.array(['{0:.2f}'.format(x)
                       for x in np.arange(min_val, max_val, step)])
    plt.figure()
    utils.plot_colorbar(cmap, labels, name)
Beispiel #6
0
def draw_graph(G, filename="traversability-graph.png", path=[]):

    G.vp.vfcolor = G.new_vertex_property("vector<double>")
    G.ep.ecolor = G.new_edge_property("vector<double>")
    G.ep.ewidth = G.new_edge_property("int")

    for v in G.vertices():
        diff = G.vp.traversability[v]
        G.vp.vfcolor[v] = [
            1 / (numpy.sqrt(diff) / 100), 1 / (numpy.sqrt(diff) / 100),
            1 / (numpy.sqrt(diff) / 100), 1.0
        ]
    for e in G.edges():
        G.ep.ewidth[e] = 6
        G.ep.ecolor[e] = [0.179, 0.203, 0.210, 0.8]

    for i, v in enumerate(path):
        G.vp.vfcolor[v] = [0, 0.640625, 0, 0.9]
        if i < len(path) - 1:
            for e in v.out_edges():
                if e.target() == path[i + 1]:
                    G.ep.ecolor[e] = [0, 0.640625, 0, 1]
                    G.ep.ewidth[e] = 10

    draw.graph_draw(G, pos=G.vp.pos, output_size=(1200, 1200), vertex_color=[0,0,0,1], vertex_fill_color=G.vp.vfcolor,\
                    edge_color=G.ep.ecolor, edge_pen_width=G.ep.ewidth, output=filename, edge_marker_size=4)
Beispiel #7
0
def plot_graph(G,node_color={},node_shape={},edge_width={},ax=None,name="graph",save=False):
    nodes = G.nodes()
    nN = len(nodes)
    index = {nodes[i]:i for i in range(nN)}
    #graph for plotting
    G0 = gt.Graph(directed=False)
    v_id = G0.new_vertex_property("int") #node ID
    v_co = G0.new_vertex_property("int") #node color
    if node_color == {}:
        color = {n:0 for n in nodes}
    else:
        color = node_color
    v_sh = G0.new_vertex_property("int") #node shape
    if node_shape == {}:
        shape = {n:0 for n in nodes}
    else:
        shape = node_shape
    vlist = []
    e_w = G0.new_edge_property("float") #edge weight
    if edge_width == {}:
        width = {e:1 for e in G.edges()}
    else:
        width = edge_width
    for n in nodes:
        v = G0.add_vertex()
        v_id[v] = n
        v_co[v] = color[n]
        v_sh[v] = shape[n]
        vlist.append(v)
    for n,p in G.edges():
        i,j = index[n],index[p]
        e = G0.add_edge(vlist[i],vlist[j])
        e_w[e] = width[(n,p)]
#    G0.vertex_properties["ID"] = v_id
#    G0.vertex_properties["Shape"] = v_ta
#    G0.vertex_properties["Color"] = v_gp
#    G0.edge_properties["Weight"] = e_w
    if save:
        G0.save(name+".xml.gz")
    #plot graph
    pos = sfdp_layout(G0,eweight=e_w)
    if ax == None:
        graph_draw(G0,pos,output_size=(1000,1000),
                   vertex_fill_color=v_co,
                   vertex_shape=v_sh,
                   vertex_size=15,
                   edge_pen_width=e_w,
                   bg_color=[1., 1., 1., 1.],
                   output=name+".png"
        )
    else:
        graph_draw(G0,pos,output_size=(1000,1000),
                   vertex_fill_color=v_co,
                   vertex_shape=v_sh,
                   vertex_size=15,
                   edge_pen_width=e_w,
                   bg_color=[1., 1., 1., 1.],
                   mplfig=ax
        )
Beispiel #8
0
def graph_draw(gr):
    gdraw.graph_draw(gr,
                     vertex_text=gr.vertex_properties['label'],
                     vertex_text_position=0.1,
                     vertex_size=10,
                     edge_text=gr.edge_properties['label'],
                     output_size=(1800, 1800),
                     fit_view=1)
Beispiel #9
0
def test_chain():
    periodic = True
    # periodic = False
    graph = gt_gen.lattice([1, 200], periodic=periodic)
    if periodic:
        figure_title = 'line_periodic'
    else:
        figure_title = 'line_non-periodic'

    n = graph.num_vertices()
    location1 = 0.2 * n
    location2 = n - location1
    jump = 1e-3
    weight = graph.new_edge_property('double', vals=1)
    e1 = graph.edge(location1, location1 + 1)
    weight[e1] = jump
    e2 = graph.edge(location2 - 1, location2)
    weight[e2] = jump

    pos_x = np.arange(n)
    pos_y = np.zeros((n,))
    v_pos = graph.new_vertex_property('vector<double>',
                                      vals=np.vstack((pos_x, pos_y)).T)
    v_text = graph.new_vertex_property('string')
    for v in graph.vertices():
        v_text[v] = pos_x[graph.vertex_index[v]]
    palette = sns.color_palette('Set1', n_colors=2)
    cmap = colors.ListedColormap(palette)
    gt_draw.graph_draw(graph, pos=v_pos, edge_color=weight, ecmap=cmap,
                       edge_pen_width=.5, vertex_fill_color='w', vertex_size=2,
                       vertex_text=v_text, vertex_font_size=1,
                       output=figure_title + '_graph.pdf')

    x_signal1 = np.cos(np.linspace(0, 4 * np.pi, location1))
    x_signal2 = np.cos(np.linspace(0, 50 * np.pi, n - 2 * location1))
    x_signal3 = np.cos(np.linspace(0, 8 * np.pi, location1))
    x_signal = np.hstack([x_signal1, x_signal2, x_signal3])

    palette = sns.color_palette('Set1', n_colors=3)
    plt.figure()
    markerline, stemlines, baseline = plt.stem(x_signal, markerfmt=' ')
    plt.setp(stemlines, color=palette[1], linewidth=1.5)
    plt.setp(baseline, color='k')
    plt.savefig(figure_title + '_signal.pdf', dpi=300)

    n_eigs = graph.num_vertices() - 1
    tau = 200
    alpha = -1e-4

    factories = [spec.ConvolutionSGFT(graph, n_eigs, tau, weight=weight),
                 spec.PageRankSGFT(graph, n_eigs, alpha, weight=weight),
                 spec.ConvolutionSGFT(graph, n_eigs, tau, weight=None),
                 spec.PageRankSGFT(graph, n_eigs, alpha, weight=None)]

    sgft.comparison.compare_spectrograms(factories, x_signal, graph, v_pos,
                                         file_name=figure_title)
    sgft.comparison.compare_localization(factories, location1, graph, v_pos,
                                         file_name=figure_title)
Beispiel #10
0
def graph_draw_closeness(gr, c):
    gdraw.graph_draw(gr,
                     vertex_text=gr.vertex_properties['label'],
                     vertex_text_position=0.1,
                     vertex_size=10,
                     edge_text=gr.edge_properties['label'],
                     output_size=(1800, 1800),
                     fit_view=1,
                     vertex_fill_color=c)
def visualize_graph(reuters_graph):
    pos = gd.fruchterman_reingold_layout(reuters_graph)
    print("Graph visualization running...")
    gd.graph_draw(reuters_graph,
                  pos=pos,
                  output_size=(1920, 1080),
                  output=FIGURES_PATH + GRAPH_VIZ)
    print("Visualization finished...")
    reuters_graph.save(FIGURES_PATH + SAVED_GRAPH_NAME, fmt="graphml")
Beispiel #12
0
def f_r_draw(gr):
    pos = gdraw.fruchterman_reingold_layout(gr)
    gdraw.graph_draw(gr,
                     pos=pos,
                     vertex_text=gr.vertex_properties['label'],
                     vertex_text_position=0.1,
                     vertex_size=10,
                     edge_text=gr.edge_properties['label'],
                     output_size=(3800, 3800),
                     fit_view=3)
def closeness_influent_nodes(graph):
    vertex_prop = gc.closeness(graph)
    gd.graph_draw(graph,
                  vertex_fill_color=vertex_prop,
                  vertex_size=gd.prop_to_size(vertex_prop, mi=5, ma=15),
                  vcmap=matplotlib.cm.gist_heat,
                  vorder=vertex_prop,
                  output_size=(1920, 1080),
                  output=FIGURES_PATH + CLOSENESS_VIZ)

    print("Visualization finished and saved...")
Beispiel #14
0
def draw(g: GT.Graph, color_mode=None, **kwargs):
    if color_mode is None:
        graph_draw(g)
    else:
        vc = None
        if color_mode == 'deg':
            vc = g.degree_property_map('total')
        graph_draw(g,
                   vertex_fill_color=vc,
                   vcmap=matplotlib.cm.gist_heat_r,
                   **kwargs)
Beispiel #15
0
def graph_draw_color(gr, out, color):
    gdraw.graph_draw(gr,
                     vertex_text=gr.vertex_properties['label'],
                     vertex_font_size=30,
                     edge_font_size=20,
                     vertex_text_position=2,
                     vertex_size=10,
                     edge_text=gr.edge_properties['label'],
                     output_size=(1800, 1800),
                     fit_view=1,
                     vertex_fill_color=color)
def draw_community(gml_fn,
                   output,
                   layout_name=None,
                   layout_kwargs=dict(),
                   **draw_kwargs):
    g = load_graph(gml_fn)

    # Sampel of graph g
    # g = GraphView(g, vfilt=lambda v: g.vertex_index[v]%2==0)
    g.vp['wdeg'] = g.degree_property_map('total', weight=g.ep['weight'])
    # g = GraphView(g, vfilt=lambda v: g.vp['wdeg'][v]>0)

    # label for hub account only in each community
    g.vp['clabel'] = g.new_vertex_property("string", val="")
    for c in np.nditer(np.unique(g.vp['community'].a)):
        cg = GraphView(g, vfilt=(g.vp['community'].a == c))
        v_hub = find_vertex(cg, cg.vp['wdeg'], cg.vp['wdeg'].fa.max())[0]
        cg.vp['clabel'][v_hub] = cg.vp['screenname'][v_hub]

    v_size = prop_to_size(
        g.vp['wdeg'],
        mi=MIN_V_SIZE,
        ma=MAX_V_SIZE,
        log=V_SIZE_LOG,
        power=V_SIZE_POWER)
    e_width = prop_to_size(
        g.ep['weight'],
        mi=MIN_E_WIDTH,
        ma=MAX_E_WIDTH,
        log=E_WIDTH_LOG,
        power=E_WIDTH_POWER)
    if layout_name is not None:
        try:
            pos = globals()[layout_name](g, **layout_kwargs)
        except KeyError as e:
            logger.critical('No such layout function found!')
            raise
    graph_draw(
        g,
        pos,
        output=output,
        vprops=dict(
            fill_color=g.vp['community'],
            # color='grey',
            size=v_size,
            pen_width=0.01,
            text=g.vp['clabel'],
            text_position='centered',
            font_size=8,),
        eprops=dict(
            pen_width=e_width,
            end_marker="arrow",),
        **draw_kwargs)
    def show(self, output_file="ast_viz.pdf"):
        """
        Draw the graph on a pdf
        :param output_file: name of the pdf file (must end with .pdf)
        :return:
        """
        pos = radial_tree_layout(self.graph, self.graph.vertex(0))
        scale = self.graph.num_vertices()

        graph_draw(self.graph, vertex_text=self.graph.vp.type,  # self.graph.vertex_index, #
                   pos=pos, vertex_font_size=scale,
                   output=output_file, output_size=(scale * 200, scale * 200))
def betweenness_influent_nodes(graph):
    vertex_prop, edge_prop = gc.betweenness(graph,
                                            weight=graph.edge_properties["weight"])
    gd.graph_draw(graph,
                  vertex_fill_color=vertex_prop,
                  vertex_size=gd.prop_to_size(vertex_prop, mi=5, ma=15),
                  edge_pen_width=gd.prop_to_size(edge_prop, mi=0.5, ma=5),
                  vcmap=matplotlib.cm.gist_heat,
                  vorder=vertex_prop,
                  output_size=(1920, 1080),
                  output=FIGURES_PATH + BETWEENNESS_VIZ)

    print("Visualization finished and saved...")
Beispiel #19
0
 def create_graph_visualizations(self, dur='week'):
     gc = Graph_Creator(dur)
     d = 'weekly'
     if dur == 'day':
         d = 'daily'
     graphs = gc.create_culumative_graphs()
     sorted_dates = sorted(graphs.iterkeys())
     for i, date in enumerate(sorted_dates):
         pos = gtdraw.sfdp_layout(graphs[date])
         gtdraw.graph_draw(graphs[date],
                           pos=pos,
                           output=project_folder + 'outputs/' + d + '/' +
                           str(i) + '.png')
Beispiel #20
0
def plot_roles_on_graph(inGraph, graphName, metric="default"):
    nodeClusters, blackList = graph_node_clusters(graphName,
                                                  inGraph,
                                                  metric=metric)
    #     print type(nodeClusters)
    #     print nodeClusters
    #     raw_input()
    #     pos = draw.sfdp_layout(inGraph)
    nodeClustersProp = inGraph.new_vertex_property('float')
    nodeClustersProp.a = np.array(nodeClusters)

    draw.graph_draw(inGraph,
                    vertex_fill_color=nodeClustersProp,
                    edge_color="black",
                    output=graphName + "_roles.pdf")
Beispiel #21
0
def batonGraph(drawGraph=False):
    '''
    A graph with NO symmetries. 
    '''
    g = generation.lattice((9, 1))
    v = g.add_vertex()
    g.add_edge(v, g.vertex(6))

    if drawGraph == True:
        draw.graph_draw(g,
                        vertex_text=g.vertex_index,
                        edge_color="black",
                        output="batton.pdf")

    return g
Beispiel #22
0
    def draw(self, **kwargs):
        r"""Convenience wrapper to :func:`~graph_tool.draw.graph_draw` that
        draws the state of the graph as colors on the vertices and edges."""

        bv, bc_in, bc_out, bc_total = self.get_overlap_blocks()
        if self.deg_corr:
            pie_fractions = bc_total.copy("vector<double>")
        else:
            pie_fractions = self.base_g.new_vp("vector<double>",
                                               vals=[ones(len(bv[v])) for v
                                                     in self.base_g.vertices()])

        gradient = kwargs.get("edge_gradient",
                              get_block_edge_gradient(self.base_g,
                                                      self.get_edge_blocks(),
                                                      cmap=kwargs.get("ecmap",
                                                                      None)))
        from graph_tool.draw import graph_draw
        return graph_draw(self.base_g,
                          vertex_shape=kwargs.get("vertex_shape", "pie"),
                          vertex_pie_colors=kwargs.get("vertex_pie_colors", bv),
                          vertex_pie_fractions=kwargs.get("vertex_pie_fractions",
                                                          pie_fractions),
                          edge_gradient=gradient,
                          **dmask(kwargs, ["vertex_shape", "vertex_pie_colors",
                                           "vertex_pie_fractions",
                                           "edge_gradient"]))
    def draw(self, **kwargs):
        r"""Convenience wrapper to :func:`~graph_tool.draw.graph_draw` that
        draws the state of the graph as colors on the vertices and edges."""

        bv, bc_in, bc_out, bc_total = self.get_overlap_blocks()
        if self.deg_corr:
            pie_fractions = bc_total.copy("vector<double>")
        else:
            pie_fractions = self.base_g.new_vp(
                "vector<double>",
                vals=[ones(len(bv[v])) for v in self.base_g.vertices()])

        gradient = kwargs.get(
            "edge_gradient",
            get_block_edge_gradient(self.base_g,
                                    self.get_edge_blocks(),
                                    cmap=kwargs.get("ecmap", None)))
        from graph_tool.draw import graph_draw
        return graph_draw(self.base_g,
                          vertex_shape=kwargs.get("vertex_shape", "pie"),
                          vertex_pie_colors=kwargs.get("vertex_pie_colors",
                                                       bv),
                          vertex_pie_fractions=kwargs.get(
                              "vertex_pie_fractions", pie_fractions),
                          edge_gradient=gradient,
                          **dmask(kwargs, [
                              "vertex_shape", "vertex_pie_colors",
                              "vertex_pie_fractions", "edge_gradient"
                          ]))
Beispiel #24
0
    def plot_graph(self,
                   fname,
                   g=None,
                   size=1000,
                   fsize=16,
                   vsize=8,
                   ptype="pdf",
                   method='arf'):
        """
        plot the grap (needs more tuning options

        :Parameter:
            - fname  : filename (will write filename.pdf)
            - size   : outputsize will be (size, size) in px [default 800]
            - fsize  : font size [default 10]
            - method : placement method to draw graph, can be one of
                       arf
                       frucht
                       radtree
                       sfdp
                       random
        """
        if g:
            draw_g = g
        else:
            draw_g = self.molg
        import graph_tool.draw
        import graph_tool.draw as gt
        g = draw_g
        if method == 'arf':
            pos = graph_tool.draw.arf_layout(draw_g, max_iter=0)
        elif method == 'frucht':
            pos = graph_tool.draw.fruchterman_reingold_layout(draw_g,
                                                              n_iter=1000)
        elif method == 'radtree':
            pos = gt.radial_tree_layout(g, g.vertex(0))
        elif method == 'sfdp':
            pos = gt.sfdp_layout(g)
        elif method == 'sfdp':
            pos = gt.random_layout(g)
        else:
            pos = None
        from graph_tool.draw import graph_draw
        graph_draw(draw_g,pos=pos, vertex_text=draw_g.vp.type, vertex_font_size=fsize, vertex_size=vsize, \
            output_size=(size, size), output=fname+"."+ptype, bg_color=[1,1,1,1])
        return
Beispiel #25
0
    def show_argmax_spectrogram_graph(s, vertex_size=20, amax_file_name=None):
        amax = np.argmax(np.abs(s), axis=0)
        n_values = np.unique(amax).size
        assignment = graph.new_vertex_property('double', vals=amax)

        if weight is None:
            edge_pen_width = 1.0
        else:
            edge_pen_width = weight

        palette = sns.color_palette('BuGn', n_colors=n_values)
        cmap = colors.ListedColormap(palette)
        gt_draw.graph_draw(graph, pos=pos, vertex_color=[0, 0, 0, 0.5],
                           vertex_fill_color=assignment, vcmap=cmap,
                           vertex_size=vertex_size, edge_color=[0, 0, 0, 0.7],
                           edge_pen_width=edge_pen_width, output=amax_file_name,
                           output_size=(1200, 1200))
Beispiel #26
0
def plot_network_random(g, inline=True, filename=None, scale=300.0):
    """
    Display a plot of the network, g, with the vertices placed in an
    unstructured, apparently random layout.  Vertices are the model
    parameters and they are connected by edges whose thickness indicates the
    value of the second order sensitivity.

    Parameters
    -----------
    g        : graph-tool graph
               The graph to plot.
    inline   : bool, optional
               Boolean indicating whether the plot should be shown inline in
               an ipython notebook.  If false the plot is created in its own
               window and is somewhat interactive.
    filename : str, optional
               If you would like to save the plot to a file specify a
               filename (with an extension of pdf or png).
    scale    : float, optional
               If you would like to resize the vertices you can change the
               value of this float.

    Returns
    --------
    graph-tool plot
    """
    for i in range(g.num_vertices()):
        g.vp['sensitivity'][i] = scale * g.vp['sensitivity'][i]

    draw.graph_draw(
        g,
        vertex_text=g.vp['param'],
        vertex_font_size=10,
        vertex_text_position=-0.1,
        # vertex_text_color='black',
        vertex_size=g.vp['sensitivity'],
        vertex_color='#006600',
        vertex_fill_color='#006600',
        vertex_halo=True,
        vertex_halo_color='#b3c6ff',
        vertex_halo_size=g.vp['confidence'],
        edge_color='#002699',
        edge_pen_width=g.ep['second_sens'],
        output_size=(600, 600),
        inline=inline,
        output=filename)
Beispiel #27
0
    def visualize(self, graph_view, seed, outfile, drawing_props):
        g = graph_view
        props = self.process_drawing_properties(g, drawing_props)
        out = os.path.join(self.results_path, 'rtl_' + drawing_props['props_type'] + '_' + outfile + '.' + props['fmt'])
        os.makedirs(os.path.dirname(out), exist_ok=True)
        print(self.graph)
        #print(seed)
        #print(type(seed))
        # TODO DOES NOT WORK PROPERLY. USE ONLY FOR SUBCATS AND RESOLVE SEED ID WITH WIKI ID MAP!!!!

        pos = radial_tree_layout(g, seed[0])
        try:
            if len(list(g.vertices())) > 0:
                graph_draw(g, pos, vprops=props['vprops'], eprops=props['eprops'],
                           output_size=(props['output_width'], props['output_height']), output=out)
        except Exception as e:
            print(e)
Beispiel #28
0
def plot_network_random(g, inline=True, filename=None, scale=300.0):
    """
    Display a plot of the network, g, with the vertices placed in an
    unstructured, apparently random layout.  Vertices are the model
    parameters and they are connected by edges whose thickness indicates the
    value of the second order sensitivity.

    Parameters
    -----------
    g        : graph-tool graph
               The graph to plot.
    inline   : bool, optional
               Boolean indicating whether the plot should be shown inline in
               an ipython notebook.  If false the plot is created in its own
               window and is somewhat interactive.
    filename : str, optional
               If you would like to save the plot to a file specify a
               filename (with an extension of pdf or png).
    scale    : float, optional
               If you would like to resize the vertices you can change the
               value of this float.

    Returns
    --------
    graph-tool plot
    """
    for i in range(g.num_vertices()):
        g.vp['sensitivity'][i] = scale * g.vp['sensitivity'][i]

    draw.graph_draw(g,
                    vertex_text=g.vp['param'],
                    vertex_font_size=10,
                    vertex_text_position=-0.1,
                    # vertex_text_color='black',
                    vertex_size=g.vp['sensitivity'],
                    vertex_color='#006600',
                    vertex_fill_color='#006600',
                    vertex_halo=True,
                    vertex_halo_color='#b3c6ff',
                    vertex_halo_size=g.vp['confidence'],
                    edge_color='#002699',
                    edge_pen_width=g.ep['second_sens'],
                    output_size=(600, 600),
                    inline=inline,
                    output=filename
                    )
Beispiel #29
0
def draw_clustering(graph, filename=None, pos=None, vmore=None,
                    emore=None, show_filling=False, curved=False,
                    cluster_index_name='cluster', osize=800):
    # graph.set_edge_filter(graph.ep['fake'], inverted=True)
    pos = pos or gtdraw.sfdp_layout(graph)
    vertex_options = {'pen_width': 0}
    vertex_options.update(add_cluster_name_and_color(graph,
                                                     cluster_index_name))
    name = graph.new_vertex_property('string')
    for i, v in enumerate(graph.vertices()):
        name[v] = str(i)
    if np.unique(graph.vp[cluster_index_name].a).size < 2:
        vertex_options['text'] = name
    if vmore:
        vertex_options.update(vmore)
    # d = count_disagreements(graph, alt_index=cluster_index_name)
    # if not show_filling:
    #     graph.set_edge_filter(graph.ep['fake'], inverted=True)
    # print(str(d.a.sum().ravel()[0]) + ' disagreements')
    if not show_filling:
        edge_options = {'pen_width': 2}
    else:
        edge_width = graph.new_edge_property('float')
        for e in graph.edges():
            if not graph.ep['fake'][e]:
                edge_width[e] = 6
            else:
                edge_width[e] = 3  # if graph.ep['sign'][e] else 1
        edge_options = {'pen_width': edge_width}
    edge_options.update(add_edge_sign_color(graph))
    # edge_options.update(add_edge_disagreement_size(graph, d))
    if emore:
        edge_options.update(emore)
    more_opts = {}
    if curved:
        from math import sqrt
        control = graph.new_edge_property("vector<double>")
        for e in graph.edges():
            d = sqrt(sum((pos[e.source()].a - pos[e.target()].a) ** 2)) / 5
            control[e] = [0.3, d, 0.7, .5*d]
        more_opts['edge_control_points'] = control
    gtdraw.graph_draw(graph, pos=pos, vprops=vertex_options,
                      eprops=edge_options, output=filename, fit_view=True,
                      output_size=(osize, int(0.7*osize)), inline=True,
                      **more_opts)
Beispiel #30
0
def plot_graph(ax, theta, d):
    precision = get_lower_diag_matrix(d, theta)

    # to calculate edges, get indices of the d largest vals in the lower triangle of the precision matrix
    p_flat = precision[np.tril_indices(d, -1)]
    # p_flat.sort()
    # dth_largest = p_flat[-d]
    # precision[np.triu_indices(d)] = p_flat[0]  # hack to help us calculate edges easiliy
    # edges = np.where(precision >= dth_largest)

    # p_flat = np.abs(p_flat / np.max(p_flat))
    p_flat = convert_weights(np.abs(p_flat))
    edges = np.tril_indices(d, -1)

    G = gt.Graph(directed=False)
    G.add_edge_list([(v1, v2) for v1, v2 in zip(edges[0], edges[1])])

    # G.add_edge(v1, v2)
    graph_draw(G, vertex_text=G.vertex_index, pen_width=p_flat, mplfig=ax)
Beispiel #31
0
 def visualize(self, graph_view, outfile, drawing_props):
     g = graph_view
     props = self.process_drawing_properties(g, drawing_props)
     out = os.path.join(
         self.results_path, 'sfdp_' + drawing_props['props_type'] + '_' +
         outfile + '.' + props['fmt'])
     os.makedirs(os.path.dirname(out), exist_ok=True)
     pos = sfdp_layout(g)
     try:
         if len(list(g.vertices())) > 0:
             graph_draw(g,
                        pos,
                        vprops=props['vprops'],
                        eprops=props['eprops'],
                        output_size=(props['output_width'],
                                     props['output_height']),
                        output=out)
     except Exception as e:
         print(e)
Beispiel #32
0
    def visualize(self, graph_view, outfile, drawing_props):
        g = graph_view
        props = self.process_drawing_properties(g, drawing_props)
        out = os.path.join(
            self.results_path, 'fr_' + drawing_props['props_type'] + '_' +
            outfile + '.' + props['fmt'])
        os.makedirs(os.path.dirname(out), exist_ok=True)

        try:
            if len(list(g.vertices())) > 0:
                # TODO: LAYOUT IST SCHEISSE. ÄNDERE DEFAULT!
                pos = fruchterman_reingold_layout(g)
                graph_draw(g,
                           pos,
                           vprops=props['vprops'],
                           eprops=props['eprops'],
                           output_size=(props['output_width'],
                                        props['output_height']),
                           output=out)
        except Exception as e:
            print(e)
Beispiel #33
0
def draw_state(n_iter, graph, history, pos):
    """draw one state"""
    edge_tuple = lambda e: (min(map(int, e)), max(map(int, e)))
    n = graph.num_vertices()
    pivot, d_edges = history[n_iter]

    vpen = graph.new_vertex_property('int')
    vpen.a = 4*(np.arange(n) == pivot)
    name = graph.new_vertex_property('string')
    name = graph.new_vertex_property('string')
    for i, v in enumerate(graph.vertices()):
        name[v] = str(i)
    vertex_options = {'size': 26, 'color': 'blue', 'pen_width': vpen,
                      'text': name}

    old_enough = graph.new_edge_property('bool')
    old_enough.a = graph.ep['depth'].a <= n_iter//2

    ecolors = [[.8, .2, .2, .8], [.2, .8, .2, .8]]
    edge_color = graph.new_edge_property('vector<float>')
    edge_width = graph.new_edge_property('int')
    for e in graph.edges():
        if edge_tuple(e) in d_edges:
            edge_width[e] = 5
            old_enough[e] = True
            if n_iter % 2 == 0:
                edge_color[e] = [.6, .6, .6, .8]
            else:
                edge_color[e] = ecolors[graph.ep['sign'][e]]
        else:
            edge_width[e] = 3
            edge_color[e] = ecolors[graph.ep['sign'][e]]

    edge_options = {'pen_width': edge_width, 'color': edge_color}

    graph.set_edge_filter(old_enough)
    gtdraw.graph_draw(graph, pos=pos, vprops=vertex_options,
                      eprops=edge_options, output=None, fit_view=True,
                      output_size=(600, 600))
    graph.set_edge_filter(None)
Beispiel #34
0
def plot(G_gt, layout_gt, n_range, palette, **kwargs):  # pylint: disable=unused-argument

    v_text = G_gt.vertex_properties['id']
    # v_degrees_p = G_gt.degree_property_map('out')
    # v_degrees_p.a = np.sqrt(v_degrees_p.a)+2
    v_degrees_p = G_gt.vertex_properties['degree']
    v_size_p = gt.prop_to_size(v_degrees_p, n_range[0], n_range[1])
    v_fill_color = G_gt.vertex_properties['fill_color']
    e_weights = G_gt.edge_properties['weight']
    e_size_p = gt.prop_to_size(e_weights, 1.0, 4.0)
    # state = gt.minimize_blockmodel_dl(G_gt)
    # state.draw(
    # c = gt.all.closeness(G_gt)

    v_blocks = gt.minimize_blockmodel_dl(G_gt).get_blocks()
    plot_color = G_gt.new_vertex_property('vector<double>')
    G_gt.vertex_properties['plot_color'] = plot_color

    for v_i, v in enumerate(G_gt.vertices()):
        scolor = palette[v_blocks[v_i]]
        plot_color[v] = tuple(int(scolor[i : i + 2], 16) for i in (1, 3, 5)) + (1,)

    gt_draw.graph_draw(
        G_gt,
        # vorder=c,
        pos=layout_gt,
        output_size=(1000, 1000),
        # vertex_text_offset=[-1,1],
        vertex_text_position=0.0,
        vertex_text=v_text,
        vertex_color=[1, 1, 1, 0],
        vertex_fill_color=v_fill_color,
        vertex_size=v_size_p,
        vertex_font_family='helvetica',
        vertex_text_color='black',
        edge_pen_width=e_size_p,
        inline=True,
    )
Beispiel #35
0
    def visualize(self, graph_view, outfile, drawing_props):
        g = graph_view
        props = self.process_drawing_properties(g, drawing_props)
        out = os.path.join(
            self.results_path, 'arf_' + drawing_props['props_type'] + '_' +
            outfile + '.' + props['fmt'])
        os.makedirs(os.path.dirname(out), exist_ok=True)

        pos = arf_layout(g, max_iter=0)
        # pos = arf_layout(g, max_iter=100, dt=1e-4)
        # According to https://git.skewed.de/count0/graph-tool/issues/239 setting max_iter and dt fixed cairo error.
        # Check quality?!
        try:
            if len(list(g.vertices())) > 0:
                graph_draw(g,
                           pos,
                           vprops=props['vprops'],
                           eprops=props['eprops'],
                           output_size=(props['output_width'],
                                        props['output_height']),
                           output=out)
        except Exception as e:
            print(e)
Beispiel #36
0
def plotg(g, layout='sfdp', pos=True):
    gg = lg2gt(g)
    if not pos:
        if layout == 'fr':
            pos = gtd.fruchterman_reingold_layout(gg)
        else:
            pos = gtd.sfdp_layout(gg)
    else:
        pos = gg.new_vertex_property("vector<double>")
        n = gg.num_vertices()
        s = 2.0 * np.pi / n
        for v in range(gg.num_vertices()):
            idx = int(gg.vertex_properties['label'][gg.vertex(v)]) - 1
            pos[gg.vertex(v)] = (n * np.cos(s * idx), n * np.sin(s * idx))

    gtd.graph_draw(gg,
                   pos,
                   vertex_text=gg.vertex_properties['label'],
                   vertex_font_size=32,
                   edge_pen_width=1,
                   edge_marker_size=15,
                   vertex_pen_width=1,
                   vertex_fill_color=[0.62109375, 0.875, 0.23828125, 1])
Beispiel #37
0
def show_window(spectrogram, v, weight=None, pos=None, file_name=None, vertex_size=10):
    window = spectrogram.get_window(v)
    window = spectrogram.graph.new_vertex_property("double", vals=window)

    if weight is None:
        edge_pen_width = 1.0
    else:
        edge_pen_width = weight

    palette = sns.color_palette("YlOrRd", n_colors=256)
    cmap = colors.ListedColormap(palette)
    gt_draw.graph_draw(
        spectrogram.graph,
        pos=pos,
        vertex_color=[0, 0, 0, 0.5],
        vertex_fill_color=window,
        vcmap=cmap,
        vertex_size=vertex_size,
        edge_color=[0, 0, 0, 0.7],
        edge_pen_width=edge_pen_width,
        output=file_name,
        output_size=(1200, 1200),
    )
Beispiel #38
0
def user_network_summary(g):
    span = "{:D MMM YYYY, HH:mm} - {:D MMM YYYY, HH:mm}".format(
        arrow.get(g.edge_properties["created_at"].a.min()),
        arrow.get(g.edge_properties["created_at"].a.max())
    )
    largest_component = label_largest_component(g, directed=False).a.sum()

    display(Markdown("### " + g.graph_properties["track"].replace("#", r"\#")))
    display(Markdown("#### " + span))

    graph_draw(g, inline=True, output_size=[1000, 1000],
               vertex_fill_color=[.2, .3, .9, .7], vertex_size=2)
    stats = pd.DataFrame([
        ["Vertices",
         g.num_vertices()],
        ["Edges",
         g.num_edges()],
        ["Avg. degree",
         float(g.num_edges()) / g.num_vertices()],
        ["Avg. clustering",
         vertex_average(g, local_clustering(g))[0]],
        ["Giant component share",
         "{:.1%}".format(largest_component / g.num_vertices())]
    ], columns=["Metric", "Value"])
    display(stats)

    bins = 20
    counts, _ = vertex_hist(g, "in", range(bins))

    plt.bar(range(1, bins), counts, align="center")

    plt.xticks(range(bins))
    plt.xlim([0.5, bins - 1])
    plt.title("Degree distribution")

    plt.show()
    def plot_snapshot(self, query, n_samples, ax=None):
        """plot one snap shot using one query and update node infection/observailability
        n_samples: num of samples used for inference
        """
        self.add_query(query)
        probas = infection_probability(self.g,
                                       self.obs_inf,
                                       n_samples=n_samples)
        # print(probas.shape)
        vcolor = self.node_colors(probas)
        vcolor[query] = 1  # highlight query

        vshape = self.node_shapes(query)
        vshape[query] = SHAPE_PENTAGON  # hack, override it

        graph_draw(
            self.g_bak,  # use the very earliest graph
            pos=self.pos,
            vcmap=self.vcmap,
            output_size=self.output_size,
            vertex_size=self.vertex_size,
            vertex_fill_color=vcolor,
            vertex_shape=vshape,
            mplfig=ax)
Beispiel #40
0
def graph_img(
        data,
        molecule_graph: Optional[Any] = None,
        return_pos: bool = False,
        pos: Optional[Any] = None,
        **kwargs: Dict[str, Any]) -> Union[None, str, Tuple[str, Any, Any]]:
    try:
        from graph_tool.draw import graph_draw
    except ImportError as e:
        if RAISE_IF_MISSING_GRAPH_TOOL:
            raise
        else:
            from sys import stderr
            stderr.write(
                'Package graph_tool could not be imported. Error was: {0}'.
                format(e))
            return None

    if molecule_graph is None:
        molecule_graph = graph(data, **kwargs)

    if molecule_graph is not None:
        io = StringIO()

        output_pos = graph_draw(
            molecule_graph,
            pos=pos,
            vertex_text=molecule_graph.vertex_properties['type'],
            vertex_font_size=10.0,
            vertex_size=50.0,
            output=io,
            fmt='svg',
            output_size=tuple([150 * ceil(sqrt(len(data.atoms)))] * 2),
            vertex_fill_color=molecule_graph.
            vertex_properties['equivalence_class'],
            **(dict(vertex_shape=molecule_graph.vertex_properties['shape'])
               if USE_DIFFERENT_ELEMENT_SHAPES else {}))

        if not return_pos:
            return io.getvalue()
        else:
            return (io.getvalue(), molecule_graph, output_pos)
    else:
        return None
Beispiel #41
0
    def draw(self, **kwargs):
        r"""Convenience wrapper to :func:`~graph_tool.draw.graph_draw` that
        draws the state of the graph as colors on the vertices and edges."""

        b = self.get_MAP()
        bv = self.g.new_vertex_property("vector<int32_t>", val=range(self.B))
        gradient = self.g.new_ep("double")
        gradient = group_vector_property([gradient])
        from graph_tool.draw import graph_draw
        return graph_draw(self.g,
                          vertex_fill_color=kwargs.get("vertex_fill_color", b),
                          vertex_shape=kwargs.get("vertex_shape", "pie"),
                          vertex_pie_colors=kwargs.get("vertex_pie_colors", bv),
                          vertex_pie_fractions=kwargs.get("vertex_pie_fractions",
                                                          self.vm),
                          edge_gradient=kwargs.get("edge_gradient", gradient),
                          **dmask(kwargs, ["vertex_shape", "vertex_pie_colors",
                                           "vertex_pie_fractions",
                                           "vertex_fill_color",
                                           "edge_gradient"]))
# graph-tool.skewed.de/
from graph_tool import Graph
from graph_tool import draw

g = Graph(directed=True)

for i in range(5):
    g.add_vertex()

v1 = g.add_vertex()
v2 = g.add_vertex()

v3 = g.vertex(2)

e1 = g.add_edge(v1, v2)
g.add_edge(v1, v3)

draw.graph_draw(g)

Beispiel #43
0
def visualisation(g, subtree_height=2):
    from cc_pivot import draw_clustering
    import draw_utils as du
    from graph_tool import draw as gdraw
    import graph_tool as gt
    import numpy as np
    import seaborn as sns
    G, E = cexp.redensify.G, cexp.redensify.EDGES_SIGN
    root = 16
    Gbfs, parents, tree = initial_spanning_tree(G, root)
    ecol, esize = du.color_graph(g, tree)
    tmap = du.map_from_list_of_edges(g, tree)
    g.set_edge_filter(tmap)
    tpos = gdraw.sfdp_layout(g)
    g.set_edge_filter(None)
    ecol, esize = du.color_graph(g, tree)
    g_halo = g.new_vertex_property('bool')
    g_halo.a[root] = True
    draw_clustering(g, pos=tpos, vmore={'size': 22, 'halo': g_halo},
                    emore={'pen_width': esize, 'color': ecol, }, osize=900)

    Bparent = deepcopy(parents)
    Bg = deepcopy(Gbfs)
    for u in Bg:
        p = Bparent[u]
        Bg[u].discard(p)

    dtree, height, strees = dfs_of_a_tree(Bg, root, Bparent, subtree_height)

    cols = sns.color_palette('rainbow', len(strees))
    random.shuffle(cols)
    ecol, esize = du.color_graph(g, tree)
    for e in tree:
        ge = g.edge(*e)
        ecol[ge] = du.light_gray  # [.25,.25,.25,.8]
        esize[ge] = 1.5
    for st, c in zip(strees, cols):
        for u, v in ((u, v) for u, v in st.items() if v is not None):
            ge = g.edge(u, v)
            ecol[ge] = c
            esize[ge] = 3
    draw_clustering(g, pos=tpos, vmore={'size': 22},
                    emore={'pen_width': esize, 'color': ecol}, osize=900)

    tree_membership = {u: i for i, st in enumerate(strees) for u in st}
    tree_root = [[k for k, v in t.items() if v is None][0] for t in strees]
    support_tree = []
    for st in strees:
        support_tree.append({(u, v) if u < v else (v, u)
                             for u, v in st.items() if v is not None})
    within_tree, across_trees = bipartition_edges(E, strees, tree_membership, support_tree)
    Gt = {i: set() for i, u in enumerate(strees)}
    Et = {e: random.choice(list(candidates))
          for e, candidates in across_trees.items()}
    for e, n in Et.items():
        add_edge(Gt, *e)

    k = gt.Graph(directed=False)
    k.add_vertex(len(strees))
    names = k.new_vertex_property('string')
    vcols = k.new_vertex_property('vector<double>')
    etext = k.new_edge_property('string')
    prev_pos = tpos.get_2d_array((0, 1))
    new_pos = np.zeros((2, len(strees)))
    stpos = k.new_vertex_property('vector<double>')
    for i, (stree_prt, root) in enumerate(zip(strees, tree_root)):
        v = k.vertex(i)
        members = sorted(stree_prt.keys())
        mpos = prev_pos[:, members]
        new_pos[:, i] = mpos.mean(1)
        stpos[v] = prev_pos[:, root]  # mpos.mean(1)
        names[v] = str(root)
        vcols[v] = list(cols[i]) + [.9, ]
    for e, n in Et.items():
        ke = k.add_edge(*e)
        etext[ke] = str(n)
    gdraw.graph_draw(k, stpos, eprops={'text': etext}, output_size=(800, 800),
                     vprops={'pen_width': 0, 'text': names, 'fill_color': vcols, 'size': 24})

    stars, _, star_membership = extract_stars(Gt)
    within_star, across_stars = bipartition_edges(Et, stars, star_membership)

    scols, ssize = k.new_edge_property('vector<double>'), k.new_edge_property('double')
    cols_s = sns.color_palette('Set1', len(stars))
    star_halo = k.new_vertex_property('bool')
    star_halo.a = np.zeros(k.num_vertices())
    for s in stars:
        star_halo[g.vertex(s.center)] = True
    for e in k.edges():
        u, v = int(e.source()), int(e.target())
        su, sv = star_membership[u], star_membership[v]
        if su == sv and stars[su].center in [u, v]:
            scols[e], ssize[e] = list(cols_s[su]) + [.9, ], 3
        else:
            scols[e], ssize[e] = [.2, .2, .2, .8], 1

    stext = k.new_edge_property('string')
    vs_cols = k.new_vertex_property('vector<double>')
    for u in k.vertices():
        vs_cols[u] = list(cols_s[star_membership[int(u)]]) + [.9]
    for candidates in across_stars.values():
        chosen = sorted(candidates)[0]
        ke = k.edge(*chosen)
        ssize[ke] = 3
        stext[ke] = str(Et[chosen])
        scols[ke] = du.black
    gdraw.graph_draw(k, stpos, vprops={'pen_width': 0, 'text': names, 'fill_color': vs_cols, 'size': 24, 'halo': star_halo},
                     eprops={'pen_width': ssize, 'color': scols, 'text': stext}, output_size=(800, 800))
Beispiel #44
0
            self.cross_pos_index[cross_pos] = cross_index
            return cross_index

    def add_road_edge(self, s_vertex, e_vertex, road):
        if self.has_edge(s_vertex, e_vertex):
            return self.g.edge(s_vertex, e_vertex)
        else:
            edge = self.g.add_edge(s_vertex, e_vertex)
            self.g.ep.level[edge] = int(road.record[self.PATHCLASS_index])
            self.g.ep.length[edge] = self.road_length(road)
            return edge

    @staticmethod
    def road_length(road):
        length = 0
        for sub_road in zip(road.shape.points[:-1], road.shape.points[1:]):
            length += distance.euclidean(sub_road[0], sub_road[1])
        return length


if __name__ == '__main__':
    shp_file = '/home/elvis/map/map-shp/Beijing2011/bj-road-epsg3785.shp'
    gt_file = '/home/elvis/map/map-shp/Beijing2011/bj-road-epsg3785.gt'
    if os.path.exists(gt_file):
        file = gt_file
    else:
        file = shp_file
    r = RoadMap(file)
    r.load()
    graph_draw(r.g, pos=r.g.vp.pos, output_size=(600, 600), output='/home/elvis/图片/2017-10-12/2.svg')
    # graph_draw(r.g, pos=r.g.vp.pos)
Beispiel #45
0
def draw_network(network, nsize="total-degree", ncolor="group", nshape="o",
                 nborder_color="k", nborder_width=0.5, esize=1., ecolor="k",
                 spatial=True, size=(600,600), dpi=75):
    '''
    Draw a given graph/network.

    Parameters
    ----------
    network : :class:`~nngt.Graph` or subclass
        The graph/network to plot.
    nsize : float, array of floats or string, optional (default: "total-degree")
        Size of the nodes; if a number, percentage of the canvas length,
        otherwize a string that correlates the size to a node attribute among
        "in/out/total-degree", "betweenness".
    ncolor : float, array of floats or string, optional (default: 0.5)
        Color of the nodes; if a float in [0, 1], position of the color in the
        current palette, otherwise a string that correlates the color to a node
        attribute among "in/out/total-degree", "betweenness" or "group".
    nshape : char or array of chars, optional (default: "o")
        Shape of the nodes (see `Matplotlib markers <http://matplotlib.org/api/markers_api.html?highlight=marker#module-matplotlib.markers>`_).
    nborder_color : char, array of char, float or array of float, optional (default: "k")
        Color of the node's border using predefined `Matplotlib colors <http://matplotlib.org/api/colors_api.html?highlight=color#module-matplotlib.colors>`_).
        or floats in [0, 1] defining the position in the palette.
    nborder_width : float or array of floats, optional (default: 0.5)
        Width of the border in percent of canvas size.
    esize : float or array of floats, optional (default: 0.5)
        Width of the edges in percent of canvas size.
    ecolor : char, array of char, float or array of float, optional (default: "k")
        Edge color.
    spatial : bool, optional (default: True)
        If True, use the neurons' positions to draw them.
    size : tuple of ints, optional (default: (600,600))
        (width, height) tuple for the canvas size (in px).
    dpi : int, optional (default: 75)
        Resolution (dot per inch).
    '''
    pos,layout = None,None
    n = network.node_nb()
    e = network.edge_nb()
    # compute properties
    if issubclass(str,nsize.__class__):
        if e:
            nsize = _node_size(network, nsize)
            nsize.a *= 0.01*size[0]
    elif issubclass(float, nsize.__class__):
        nsize = np.repeat(nsize, n)
    if issubclass(str,esize.__class__):
        if e:
            esize = _edge_size(network, esize)
            esize.a *= 0.01*size[0]
    elif issubclass(float, esize.__class__):
        esize = np.repeat(esize, e)
        esize = network.graph.new_edge_property("double",esize)
    ncolor = _node_color(network, ncolor)        
    if issubclass(float, nborder_color.__class__):
        nborder_color = np.repeat(nborder_color, n)
    if issubclass(float, ecolor.__class__):
        ecolor = np.repeat(ecolor, e)
    # draw
    pos = np.zeros((n,2))
    if not e:
        nsize = 0.02*size[0]
        esize = 0.01*size[0]
        if spatial and network.is_spatial():
            pos = network[POS]
        else:
            pos[:,0] = size[0]*(np.random.uniform(size=n)-0.5)
            pos[:,1] = size[1]*(np.random.uniform(size=n)-0.5)
    elif spatial and network.is_spatial():
        pos = network[POS]
        pos = network.graph.new_vertex_property("vector<double>",pos)
    else:
        ebetw = network.graph.betweenness_list(as_prop=True)[1]
        pos = gplot.sfdp_layout(network.graph, eweight=ebetw)
    if not e:
        size_inches = (size[0]/float(dpi),size[1]/float(dpi))
        fig = plt.figure(facecolor='white', figsize=size_inches, dpi=dpi)
        ax = fig.add_subplot(111, frameon=0, aspect=1)
        fig.facecolor = "white"
        fig.figsize=size
        ax.set_axis_off()
        if hasattr(network, "population"):
            for group in network.population.itervalues():
                idx = group.id_list
                ax.scatter(pos[idx,0], pos[idx,1], s=nsize,
                           color=palette(ncolor[idx[0]]))
        else:
            ax.scatter(pos[:,0], pos[:,1], s=nsize)
        ax.set_xlim([-0.51*size[0],0.51*size[0]])
        ax.set_ylim([-0.51*size[1],0.51*size[1]])
        plt.show()
    elif spatial and network.is_spatial():
        gplot.graph_draw(network.graph, pos=pos, vertex_color=nborder_color,
            vertex_fill_color=ncolor, vertex_size=nsize, edge_color=ecolor,
            edge_pen_width=esize, output_size=size)
    else:
        gplot.graph_draw(network.graph, pos=pos, vertex_color=nborder_color,
            vertex_fill_color=ncolor, vertex_size=nsize, edge_color=ecolor,
            edge_pen_width=esize, output_size=size)
Beispiel #46
0
             g.v[g.v['layer'] == layer].y.max() + margin,
             layer, fontsize=15)


# We can also plot the supergraph $G^L = (V^L, E^L)$

# In[17]:

# create graph_tool graph of lg
gtg = lg.return_gt_graph(relations=True, node_indices=True, edge_indices=True)

# create plot
gtd.graph_draw(gtg,
               vertex_text=gtg.vp['i'], vertex_text_position=-2,
               vertex_fill_color='w',
               vertex_text_color='k',
               edge_text=gtg.ep['n_edges'],
               inline=True, fit_view=.8,
               output_size=(400,400))


# ### The SuperGraph $G^N = (V^N, E^N)$

# Partitioning by the type of feature ``V_N`` leads to the supergraph $G^{N} = (V^{N}, E^{N})$, where each supernode $V^{N}_{i^N} \in V^{N}$ corresponds to a node of the MLN. Superedges $E^{N}_{i^N j^N} \in E^{N}$ with $i^N = j^N$ correspond to the coupling edges of a MLN.

# In[18]:

# partition by MLN's node indices
nv, ne, gv, ge = g.partition_graph('V_N', return_gve=True)

# for each superedge, get types of edges and their weights
def render_graph(g, path='graph/{}.pdf'):

    # the simplest way
    arg_map = dict(
        g = g,
        output = path.format('1-1-random-simplest'),
    )
    graph_draw(**arg_map)

    # use constants
    arg_map.update(dict(
        output = path.format('1-2-random-constant'),
        output_size = (SIZE, SIZE),
        vertex_size = MA_V_SIZE,
        edge_pen_width = MA_E_PWIDTH,
    ))
    graph_draw(**arg_map)

    # use prop_to_size
    v_count_p = g.vp['count']
    e_count_p = g.ep['count']
    v_size_by_count_p = prop_to_size(v_count_p, MI_V_SIZE, MA_V_SIZE)
    e_pwidth_by_count_p = prop_to_size(e_count_p, MI_E_PWIDTH, MA_E_PWIDTH)
    arg_map.update(dict(
        output = path.format('1-3-random-size'),
        vertex_size = v_size_by_count_p,
        edge_pen_width = e_pwidth_by_count_p,
    ))
    graph_draw(**arg_map)

    # use fill_color
    debug('v_count_p.a         : {}', v_count_p.a)
    v_color_by_count_p = prop_to_size(v_count_p, 0, 1)
    debug('v_color_by_count_p.a: {}', v_color_by_count_p.a)
    arg_map.update(dict(
        output = path.format('1-4-random-color'),
        vertex_fill_color = v_color_by_count_p,
    ))
    graph_draw(**arg_map)

    # use closeness
    v_closeness_p = g.vp['closeness']
    v_color_by_closeness_p = prop_to_size(v_closeness_p, 0, 1)
    #closeness_arg_map = arg_map.copy()
    #closeness_arg_map.update(dict(
    #    output = path.format('1-5-random-closeness'),
    #    vertex_fill_color = v_color_by_closeness_p,
    #))
    arg_map.update(dict(
        output = path.format('1-5-random-closeness'),
        vertex_fill_color = v_color_by_closeness_p,
    ))
    graph_draw(**arg_map)

    # sfdp_layout
    arg_map.update(dict(
        output = path.format('2-1-sfdp'),
        pos = sfdp_layout(g),
    ))
    graph_draw(**arg_map)

    # sfdp_layout with only edge's weight
    arg_map.update(dict(
        output = path.format('2-2-sfdp-edge-weight'),
        pos = sfdp_layout(g, eweight=e_count_p),
    ))
    graph_draw(**arg_map)

    # sfdp_layout with both edge and vertex's weight
    arg_map.update(dict(
        output = path.format('2-3-sfdp-both-weight'),
        pos = sfdp_layout(g, eweight=e_count_p, vweight=v_count_p),
    ))
    graph_draw(**arg_map)

    # fruchterman_reingold_layout
    arg_map.update(dict(
        output = path.format('3-1-fr'),
        pos = fruchterman_reingold_layout(g),
    ))
    graph_draw(**arg_map)

    # fruchterman_reingold_layout with edge's weight
    arg_map.update(dict(
        output = path.format('3-2-fp-edge-weight'),
        pos = fruchterman_reingold_layout(g, weight=e_count_p),
    ))
    graph_draw(**arg_map)

    # arf_layout
    arg_map.update(dict(
        output = path.format('4-1-arf'),
        pos = arf_layout(g),
    ))
    graph_draw(**arg_map)

    # arf_layout with edge's weight
    arg_map.update(dict(
        output = path.format('4-2-arf-edge-weight'),
        pos = arf_layout(g, weight=e_count_p),
    ))
    graph_draw(**arg_map)