Python pydot.graph_from_edges函数代码示例

def modalsmap(words,conditionals):
    '''
    given a speech list in the form of {'YOUNG SIWARD': ['What', 'is','thy',
    'name','?'], } creates a graphviz map of conditionals per (important)
    character
    '''
    import pydot

    all = []
    for char, words in conditionals.items():
        for word in words:
            all.append((char,word[0].lower()))

            
    graphic = pydot.graph_from_edges(all)
    for char in conditionals:
        new = pydot.Node(char,color='green',shape='doubleoctagon',fontname='Arial',fontsize='12',rank='source', ranksep = '1.2')
        graphic.add_node(new)
    for char, word in all:
        new = pydot.Node(word,color='purple',shape='note',fontname='Arial',fontsize='8')
        graphic.add_node(new)


    graphic.set_overlap('TRUE')
    graphic.set_splines('True')
    graphic.set_suppress_disconnected('TRUE')
    graphic.write_png('/tmp/test.png',prog='twopi')

def create_node_graph(output = "jpg"):
    nodes = {}
    switch_edge_ports = {} 
    edge_list = [] 

    for link in discovery.adjacency_list:    
        node1_name = longlong_to_octstr(link[0])[6:].replace(':','')
        node2_name = longlong_to_octstr(link[2])[6:].replace(':','')
        nodes[node1_name] = True
        nodes[node2_name] = True
        edge_list.append((node1_name, node2_name))
        switch_edge_ports[(node1_name, node2_name)] = (link[1], link[3])

    g = pydot.graph_from_edges(edge_list, directed=True)

    # for all edge inferred by discovery, set port labels    
    for linkt in switch_edge_ports:
        edgel = g.get_edge(linkt[0], linkt[1])
        if type(edgel) != type([]):
            edgel.set('headlabel',str(switch_edge_ports[linkt][1]))
            edgel.set('taillabel',str(switch_edge_ports[linkt][0]))
        else:    
            for edge in edgel:
                edge.set('headlabel',str(switch_edge_ports[linkt][1]))
                edge.set('taillabel',str(switch_edge_ports[linkt][0]))

    for node in g.get_node_list():
        node.set('style', 'filled,setlinewidth(2)')
        node.set('fillcolor', '#ffffcc')
        node.set('color', '#99cc99')
        node.set('tooltip', 'switch')

    return dot_output(g, "pyapps/www/discovery."+output)

def graph(x, name=None):
    """Display a directed graph of the Component structure of x

    :param x: A Component or Manager to graph
    :type  x: Component or Manager

    :param name: A name for the graph (defaults to x's name)
    :type  name: str

    @return: A directed graph representing x's Component sturcture.
    @rtype:  str
    """

    def getname(c):
        return "%s-%s" % (c.name, md5(str(hash(c))).hexdigest()[-4:])

    if HAS_PYDOT:
        graph_edges = []
        for (u, v) in edges(x):
            graph_edges.append(("\"%s\"" % getname(u), "\"%s\"" % getname(v)))

        g = pydot.graph_from_edges(graph_edges, directed=True)
        g.write("%s.dot" % (name or x.name))
        g.write("%s.png" % (name or x.name), format="png")

    def printer(d, x):
        return "%s* %s" % (" " * d, x)

    return "\n".join(walk(x, printer))

def graph_to_pydot(g, **kwds):
    """ Return a pydot Graph from a graph.

    :Parameters: 

        - `g`: a graph implementing :class:`openalea.container.interface.graph.IEdgeListGraph` interface.
        -`prog`: default is dot. value must one of :

            * dot for hierarchical layout of directed graph
            * neato and fdp for spring model layouts
            * twopi for radial layout
            * circo for circular layout

    :Returns: 

        - A pydot graph.

    :Examples:

        >>> dotg = graph_to_pydot(g)
        >>> dotg.write_svg('toto.svg', prog='circo')

    """
    edges = set((str(g.source(eid)), str(g.target(eid))) for eid in g.edges())
    graph = pydot.graph_from_edges(edges, directed=True)

    return graph

def makebranchgrapsh(data, commdct):
    """return the edges for the all branches"""
    allgraphs = []
    alledges = []

    objkey = 'BRANCH'
    cnamefield = "Component %s Name"
    inletfield = "Component %s Inlet Node Name"
    outletfield = "Component %s Outlet Node Name"

    numobjects = len(data.dt[objkey])
    cnamefields = loops.repeatingfields(data, commdct, objkey, cnamefield)
    inletfields = loops.repeatingfields(data, commdct, objkey, inletfield)
    outletfields = loops.repeatingfields(data, commdct, objkey, outletfield)

    inlts = loops.extractfields(data, commdct, 
        objkey, [inletfields] * numobjects)
    cmps = loops.extractfields(data, commdct, 
        objkey, [cnamefields] * numobjects)
    otlts = loops.extractfields(data, commdct, 
        objkey, [outletfields] * numobjects)

    zipped = list(zip(inlts, cmps, otlts))
    tzipped = [transpose2d(item) for item in zipped]
    for i in range(len(data.dt[objkey])):
        tt = tzipped[i]
        # branchname = data.dt[objkey][i][1]
        edges = []
        for t0 in tt:
            edges = edges + [(t0[0], t0[1]), (t0[1], t0[2])]
        g=pydot.graph_from_edges(edges, directed=True)
        allgraphs.append(g)
        alledges = alledges + edges
    return alledges

def read_graph(fname):
    g = pydot.graph_from_edges([])

    # g = read_as_info(g, '%s.as_info' % fname)
    g = read_edges(g, "%s.edges" % fname)

    return g

def plot2d(g, image_name, scale=None, orientation=90 ):
    """Compute an image of the tree via graphviz.

    :Parameters:

        - `g` (int) : an MTG object
        - `image_name` (str) : output filename e.g. test.png

    :Optional parameters:

        - `scale` (int): represents the MTG's scale to look at (default max)
        - `orientation` (int): orientation angle (default 90)

    """
    import pydot
    if scale is None:
        scale = max(g.scales_iter())
    label = g.property('label')
    edges = g.iteredges(scale=scale)

    if label:
        f = lambda id: label.get(id, str(id))
    else:
        f = str
    pydot_graph = pydot.graph_from_edges(((f(x), f(y)) for x, y in g.iteredges(scale=scale)))

    # Attributes
    pydot_graph.set('orientation', orientation)

    ext = os.path.splitext(image_name)[1].strip('.')
    return pydot_graph.write(image_name, prog='dot',format=ext)

def grph(edges,filename):
   g=pydot.graph_from_edges(edges) 
   if filename:
       f = filename + ".svg"
   else:
       f = "graph.svg"
   g.write_svg(f, prog='dot') 

def plot_graph(rel, file_name):
    import pydot # import pydot or you're not going to get anywhere my friend :D 

    # first you create a new graph, you do that with pydot.Dot()
    #graph = pydot.Dot(graph_type='digraph')

    graph = pydot.graph_from_edges(rel, directed = True)
    graph.write_png(file_name)

def showGraph(chunkList): #chunkのリストを受け取って、そこからグラフを表示までやってくれる関数を作る
    edges = []
    for c in chunkList:
        if c.dst != -1:
            edges.append((c.getText().encode('utf-8'),chunkList[c.dst].getText().encode('utf-8'))) #cがかかりもと、chunkList[c.dst]がかかり先のchunkインスタンス

    g = pydot.graph_from_edges(edges,directed = True)
    g.write_jpeg('dot.jpg', prog='dot')

def graph(node, filename=None):
    edges = descend(node)
    g = pydot.graph_from_edges(edges)
    if filename is not None:
        f = filename + ".png"
    else:
        f = "graph.png"
    g.write(f, prog="dot", format="png")

def graph(node, filename):
	edges = descend(node)
	g=pydot.graph_from_edges(edges) 
	if filename:
		f = filename + ".png"
	else:
		f = "graph.png"
	g.write_png(f, prog='dot') 

    def make_dot(self):
        import pydot

        edges = []
        for node in self.toplevel_nodes:
            for claimed in node.claimed_nodes:
                edges.append((str(node), str(claimed)))
        g = pydot.graph_from_edges(edges)
        g.write_jpeg("graph_from_edges_dot.jpg", prog="dot")

def run():
    if len(sys.argv) != 2:
        print >> sys.stderr, 'Usage: %s filename' % os.path.basename(sys.argv[0])
        return 1
        
    edges = [map(int, l[:-1].split()) for l in open(sys.argv[1])][1:]
    
    g = pydot.graph_from_edges(edges)
    basename = sys.argv[1][:sys.argv[1].rfind('.')]
    g.write_png(basename + '.png')

def create_graph(edges, seq):

    graph = pydot.graph_from_edges(edge_list=edges, directed=True)

    # フォント設定
    n = pydot.Node("node")
    n.fontname = "Osaka.ttf"
    n.fontsize = 9
    graph.add_node(n)

    # グラフを出力
    graph.write_png("graph/graph_from_edges_dot_" + str(seq) + ".png", prog="dot")