Esempio n. 1
0
 def __init__(self):
     """
     Initializes graph parameters.
     """
     self.g = Graph()
     self.vertex_id = 0
     self.edge_id = 0
Esempio n. 2
0
class GraphMLExporter():
    """
    """

    def __init__(self, lines):
        """
        """

        self.lines = lines
        self.graph = Graph()
        self.i = 0

        self.createGraph()

    def createGraph(self):
        """
        """

        mul = 100

        for line in self.lines:

            n1 = self.checkNode(str(self.i))
            n2 = self.checkNode(str(self.i))

            n1['x'] = line.p1.x * mul
            n1['y'] = line.p1.y * mul
            n1['z'] = line.p1.z * mul

            n2['x'] = line.p2.x * mul
            n2['y'] = line.p2.y * mul
            n2['z'] = line.p2.z * mul

            self.graph.add_edge(n1, n2)

    def checkNode(self, label):
        """
        """

        exist = False
        
        for n in self.graph.nodes():
            if label == n['label']:
                exist = True
                node = n

        if exist:
            return node
        else:
            self.i += 1
            return self.graph.add_node(label)
            

    def write(self, ):
        """
        """

        parser = GraphMLParser()
        parser.write(self.graph, "graph.graphml")
Esempio n. 3
0
class GraphMLExporter():
    """
    """
    def __init__(self, lines):
        """
        """

        self.lines = lines
        self.graph = Graph()
        self.i = 0

        self.createGraph()

    def createGraph(self):
        """
        """

        mul = 100

        for line in self.lines:

            n1 = self.checkNode(str(self.i))
            n2 = self.checkNode(str(self.i))

            n1['x'] = line.p1.x * mul
            n1['y'] = line.p1.y * mul
            n1['z'] = line.p1.z * mul

            n2['x'] = line.p2.x * mul
            n2['y'] = line.p2.y * mul
            n2['z'] = line.p2.z * mul

            self.graph.add_edge(n1, n2)

    def checkNode(self, label):
        """
        """

        exist = False

        for n in self.graph.nodes():
            if label == n['label']:
                exist = True
                node = n

        if exist:
            return node
        else:
            self.i += 1
            return self.graph.add_node(label)

    def write(self, ):
        """
        """

        parser = GraphMLParser()
        parser.write(self.graph, "graph.graphml")
Esempio n. 4
0
    def __init__(self, lines):
        """
        """

        self.lines = lines
        self.graph = Graph()
        self.i = 0

        self.createGraph()
def loadgraph(addr):
    gphml = Graph()
    gmatrix = loadmat(addr)["A"].toarray()
    for i in range(len(gmatrix)):
        n = gphml.add_node()
        n.id = str(i)
    for i in range(len(gmatrix)):
        for j in range(i + 1, len(gmatrix)):
            if gmatrix[i, j] == 1:
                gphml.add_edge_by_id(str(i), str(j))
    return gphml
Esempio n. 6
0
def createGraphML():
    global g
    g = Graph()
    c.execute('select uid from userdata')
    dataList = c.fetchall()
    gnodes = []
    edges = []
    for i in dataList:
        i = str(i)
        i = i.replace("(", "").replace(",)", "").replace("L", "")
        i = int(i)
        c.execute('select distinct low from graphdata where high=?', (i, ))
        relate = c.fetchall()
        if not i in gnodes:
            g.add_node(i)
            gnodes.append(i)

        for e in relate:
            e = str(e)
            e = e.replace("(", "").replace(",)", "").replace("L", "")
            e = int(e)
            if not e in gnodes:
                g.add_node(e)
                gnodes.append(e)

# 		 	edges.append(i)
# 		 	edges.append(e)
#1 		 	if edges2.count(e) > 1:
            g.add_edge_by_label(str(i), str(e))

    parser = GraphMLParser()
    parser.write(g, "myGraph.graphml")
Esempio n. 7
0
def do_harvest(query, iterations):
    book_data = {}
    currentPosition = 0
    query_string = QUERY_FORMAT_STRING.format(query)

    graph = Graph()
    parser = JSONParser.JSONParser()

    # map for collecting nodes
    nodes = {}
    while (iterations > len(nodes)):
        page = requests.get(query_string)
        tree = html.fromstring(page.content)

        links = tree.xpath('//table[@id="searchresult"]//a/@href')

        if (len(links) == 0):
            break

        for link in links:
            book_info_response = requests.get(BASE_URL_DNB + link)
            get_data_from_book_info(book_data, book_info_response, "Titel")
            get_data_from_book_info(book_data, book_info_response,
                                    "Person(en)")
            get_data_from_book_info_link(book_data, book_info_response,
                                         "Schlagwörter")

            if (len(book_data['Schlagwörter']) > 0):
                for v in book_data.values():
                    print(v)

                for s in book_data['Schlagwörter']:
                    node = None
                    node = graph.add_node(s)
                    nodes[s] = node

                s1 = book_data['Schlagwörter'][0]
                for s in book_data['Schlagwörter']:
                    if s != s1:
                        edge = graph.add_edge(nodes[s1], nodes[s])
                        edge['label'] = book_data['Titel']

        query_string = QUERY_FORMAT_STRING_2.format(query,
                                                    str(currentPosition))
        currentPosition += len(links)
        iterations -= 1
    return parser.tostring(graph)
Esempio n. 8
0
    def writeFile(self, filename):
        g = Graph()

        for i in self.nodes:
            node = self.nodes[i]
            node.name = str(i)
            gnode = g.add_node(i)
            gnode['label'] = i
            gnode['x'] = node.x
            gnode['y'] = node.y

        for i in self.edges:
            edge = self.edges[i]
            edge.name = i

        parser = GraphMLParser()
        parser.write(g, filename)
Esempio n. 9
0
def createGraphML():
	global g
	g = Graph()
	c.execute('select uid from userdata')
	dataList = c.fetchall() 
	gnodes=[]
  	edges=[]
	for i in dataList: 
		 i=str(i)
 		 i = i.replace("(","").replace(",)","").replace("L","") 
 		 i= int(i)
		 c.execute('select distinct low from graphdata where high=?', (i,))
		 relate=c.fetchall()
 		 if not i in gnodes: 
 		 	g.add_node(i)
 		 	gnodes.append(i)
   		 	
 		 for e in relate: 
  		 	e=str(e) 
  		 	e = e.replace("(","").replace(",)","").replace("L","")
  		 	e=int(e) 
  		 	if not e in gnodes: 
  		 		g.add_node(e)
  		 		gnodes.append(e)
		 	g.add_edge_by_label(str(i), str(e))
 	
 	parser = GraphMLParser() 
 	parser.write(g, "myGraph.graphml") 	
Esempio n. 10
0
 def from_graphml(fname: str) -> Graph:
     parser = GraphMLParser()
     gml = parser.parse(fname)
     g = Graph()
     for node in gml._nodes:
         g.adj[Node(id=node.id)]
     for edge in gml._edges:
         g.adj[Node(id=edge.node1.id)].append(Node(id=edge.node2.id))
     return g
Esempio n. 11
0
    def __init__(self, lines):
        """
        """

        self.lines = lines
        self.graph = Graph()
        self.i = 0

        self.createGraph()
Esempio n. 12
0
def create_graph():
    Item.ID = 0
    g = Graph()

    n1 = g.add_node("A")
    n2 = g.add_node("B")
    n3 = g.add_node("C")
    n4 = g.add_node("D")
    n5 = g.add_node("E")

    g.add_edge(n1, n3)
    g.add_edge(n2, n3)
    g.add_edge(n3, n4)
    g.add_edge(n3, n5)
    return g
Esempio n. 13
0
def writeToGraphml(pages, fileName):
    graph = Graph()
    nodes = []
    # creating nodes
    for page in pages:
        node = graph.add_node(page.id)
        node['title'] = page.title
        node['url'] = page.url
        if not page.mainCategory is None:
            node['main_category'] = page.mainCategory.title
        nodes.append(node)
    # creating edges
    for page in pages:
        # if there are edges
        if page.linksTo:
            for pageId in page.linksTo:
                e = graph.add_edge(nodes[page.id], nodes[pageId])
                e.set_directed(True)
    parser = GraphMLParser()
    parser.write(graph, fileName)
Esempio n. 14
0
    def __write_graphML(self):
        """Writes the .graphml file.
        
        Uses class Graph from pygraphml library to create the graph. 
        Also it uses class GraphMLParser from pygraphml library to write the file.
        """
        gr = Graph()

        # Adding nodes in the graph with properties.
        for sub in self.nodes_prop.keys():
            n = gr.add_node(sub)
            for pair_prop in self.nodes_prop[sub]:
                n[pair_prop[0]] = pair_prop[1]

        # Adding nodes in the graph without properties.
        for node in self.nodes.values():
            if node not in self.nodes_prop.keys():
                gr.add_node(node)

        # Checking the relations between nodes and creating respective edges.
        for relation in self.relations:
            source = self.nodes[relation[0]]
            target = self.nodes[relation[2]]
            edge = gr.add_edge_by_label(source, target)
            edge.set_directed(True)
            edge['model'] = relation[1]

        # Writting the file.
        parser = GraphMLParser()
        file_name = self.file_name.split(".")
        file_name = file_name[0]

        parser.write(gr, file_name + ".graphml")
        print("File  " + file_name + ".graphml is succesfully written")
Esempio n. 15
0
def generate_graph_with_clusters(summary, attr):
	from pygraphml import Graph
	items = summary.items()
	labels = np.array([artist for artist, obj in items])

	g = Graph()

	for artist in labels:
		g.add_node(artist)

	if attr == "emotion":
		for category in EMOTION_CATEGORIES:
			g.add_node(category)
	elif attr == "topic":
		for category in TOPIC_CATEGORIES:
			g.add_node(category)

	for artist_id, x in enumerate(items):
		arist, obj = x

		if attr == "emotion":
			for idx, score in enumerate(obj["emotions"]):
				edge = g.add_edge_by_label(EMOTION_CATEGORIES[idx], labels[artist_id])
				if score == 0:
					edge["weight"] = 0.001 # Set to very small value
				else:
					edge["weight"] = score

		elif attr == "topic":
			for idx, score in enumerate(obj["topics"]):
				edge = g.add_edge_by_label(TOPIC_CATEGORIES[idx], labels[artist_id])
				if score == 0:
					edge["weight"] = 0.001 # Set to very small value
				else:
					edge["weight"] = score

	return g
Esempio n. 16
0
def generate_chain(screen_name, store_graph):

    fh = open("downloaded/%s/tweets.txt" % screen_name, "r")

    chain = {}

    g = Graph()
    nodes = {}

    def generate_trigram(words):
        if len(words) < 3:
            return
        for i in range(len(words) - 2):
            yield (words[i], words[i + 1], words[i + 2])

            if ((words[i], words[i + 1]) in nodes):
                if ((words[i + 2]) in nodes):
                    g.add_edge(nodes[(words[i], words[i + 1])],
                               nodes[(words[i + 2])])
                else:
                    nodes[(words[i + 2])] = g.add_node(words[i + 2])
                    g.add_edge(nodes[(words[i], words[i + 1])],
                               nodes[(words[i + 2])])
            else:
                nodes[(words[i],
                       words[i + 1])] = g.add_node(words[i] + words[i + 1])
                if ((words[i + 2]) in nodes):
                    g.add_edge(nodes[(words[i], words[i + 1])],
                               nodes[(words[i + 2])])
                else:
                    nodes[(words[i + 2])] = g.add_node(words[i + 2])
                    g.add_edge(nodes[(words[i], words[i + 1])],
                               nodes[(words[i + 2])])

    for line in fh.readlines():
        words = line.split()
        for word1, word2, word3 in generate_trigram(words):
            key = (word1, word2)
            if key in chain:
                chain[key].append(word3)
            else:
                chain[key] = [word3]

    if (store_graph):
        parser = GraphMLParser()
        parser.write(g, "downloaded/%s/graph.graphml" % screen_name)

    pickle.dump(chain, open("downloaded/%s/chain.p" % screen_name, "wb"))
Esempio n. 17
0
def generate_graph(similarity, attr):
	from pygraphml import Graph
	items = similarity.items()
	labels = np.array([artist for artist, obj in items])

	network = np.zeros((labels.size, labels.size))

	g = Graph()

	for artist in labels:
		g.add_node(artist)

	for artist_id, x in enumerate(items):
		network[artist_id, artist_id] = 1
		artist, obj = x

		if attr == "emotion":
			for idx, score in enumerate(obj["emotion_sim"]):
				if network[artist_id, idx] == 0 and network[idx, artist_id] == 0:
					edge = g.add_edge_by_label(labels[artist_id], labels[idx])
					if score == 0:
						edge["weight"] = 0.001
					else:
						edge["weight"] = score
					network[artist_id, idx] = 1
					network[idx, artist_id] = 1
		elif attr == "topic":
			for idx, score in enumerate(obj["topic_sim"]):
				if network[artist_id, idx] == 0 and network[idx, artist_id] == 0:
					edge = g.add_edge_by_label(labels[artist_id], labels[idx])
					if score == 0:
						edge["weight"] = 0.001
					else:	
						edge["weight"] = score
					network[artist_id, idx] = 1
					network[idx, artist_id] = 1

	return g
Esempio n. 18
0
class DirectedEdge(Edge):
    def __init__(self, src, dst, weight):
        Edge.__init__(self, src, dst, weight)

    def add_to_graph(self, g, nodes):
        g.add_edge(nodes[self.src], nodes[self.dst], directed=True)


Nodes = {}
Values = {}
Allocations = {}

args = sys.argv[1:]

g = Graph()

# Find all allocations and values
with open(args[0], 'r') as f:
    for line in f:
        j = json.loads(line)
        if "allocation" in j:
            alloc = j["allocation"]
            Id = int(alloc["id"])
            pos = int(alloc["pos"])
            size = int(alloc["size"])
            AS = json.loads(alloc["addrsp"])
            AM = json.loads(alloc["mem"])
            pagetype = alloc["type"]
            as_type = AS["type"]
            newAlloc = Allocation(Id, pos, size, pagetype, as_type)
def get_data_from_book_info (book_data, response, field_name):
    tree = html.fromstring(response.content)
    field_data = tree.xpath('//td/strong[text() = "{}"]/../../td/text()'.format(field_name))
    field_string = ""
    for field in field_data:
        field_string = field_string + field.replace("\n","").replace("\r","").replace("\t","")

    book_data[field_name] = field_string

if __name__ == "__main__":
    book_data = {}
    currentPosition = 0;
    query_string = QUERY_FORMAT_STRING.format(QUERY);
    file_handles = {};
    graph = Graph();
    parser = GraphMLParser()
    filename = "book_data_" + QUERY + ".graphml"
    # map for collecting nodes
    nodes = {}
    while(True):
        page = requests.get(query_string)
        tree = html.fromstring(page.content)

        links = tree.xpath('//table[@id="searchresult"]//a/@href')

        if(len(links) == 0):
            break;

        for link in links:
            book_info_response = requests.get(BASE_URL_DNB + link)
Esempio n. 20
0
from pygraphml import Graph

# Create graph

g = Graph()

n1 = g.add_node("A")
n2 = g.add_node("B")
n3 = g.add_node("C")
n4 = g.add_node("D")
n5 = g.add_node("E")

g.add_edge(n1, n3)
g.add_edge(n2, n3)
g.add_edge(n3, n4)
g.add_edge(n3, n5)
g.show()
Esempio n. 21
0
# binary tree with a "deep and cheap" left half and an expensive but shallow right half

from pygraphml import Graph, GraphMLParser

test2 = Graph()

a = test2.add_node("A")
b = test2.add_node("B")
c = test2.add_node("C")
d = test2.add_node("D")
e = test2.add_node("E")
f = test2.add_node("F")
g = test2.add_node("G")
h = test2.add_node("H")
i = test2.add_node("I")
j = test2.add_node("J")
k = test2.add_node("K")
l = test2.add_node("L")
m = test2.add_node("M")
n = test2.add_node("N")
o = test2.add_node("O")
p = test2.add_node("P")
q = test2.add_node("Q")
r = test2.add_node("R")
s = test2.add_node("S")

test2.add_edge(a, b, directed=True)
test2.add_edge(b, c, directed=True)
test2.add_edge(b, d, directed=True)
test2.add_edge(c, e, directed=True)
test2.add_edge(c, f, directed=True)
Esempio n. 22
0
# Toy problem from the textbook: Romanian road map

from pygraphml import Graph, GraphMLParser

romania = Graph()

oradea = romania.add_node("Oradea")
zerind = romania.add_node("Zerind")
arad = romania.add_node("Arad")
sibiu = romania.add_node("Sibiu")
fagaras = romania.add_node("Fagaras")
timisoara = romania.add_node("Timisoara")
rv = romania.add_node("Rimnicu Vilcea")
lugoj = romania.add_node("Lugoj")
pitesti = romania.add_node("Pitesti")
mehadia = romania.add_node("Mehadia")
drobeta = romania.add_node("Drobeta")
craiova = romania.add_node("Craiova")
bucharest = romania.add_node("Bucharest")
giurgiu = romania.add_node("Giurgiu")
urziceni = romania.add_node("Urziceni")
neamt = romania.add_node("Neamt")
iasi = romania.add_node("Iasi")
vaslui = romania.add_node("Vaslui")
hirsova = romania.add_node("Hirsova")
eforie = romania.add_node("Eforie")

o2z = romania.add_edge(oradea, zerind, directed=False)
o2z['weight'] = 71

z2a = romania.add_edge(zerind, arad, directed=False)
Esempio n. 23
0
    def displayGroundTruth(self,agent=WORLD,x0=0,y0=0,maxRows=10,recursive=False,selfCycle=False):
        if agent == WORLD:
            self.clear()
            if __graph__:
                self.xml = Graph()
            else:
                self.xml = None
        
        x = x0
        y = y0
        if agent == WORLD:
            if not self.graph:
                self.graph = graph.DependencyGraph(self.world)
                self.graph.computeGraph()
            g = self.graph
            state = self.world.state
        else:
            g = self.graph = graph.DependencyGraph(self.world)
            state = self.world.agents[agent].getBelief()
            assert len(state) == 1
            g.computeGraph(state=next(iter(state.values())),belief=True)
        layout = getLayout(g)
        if agent == WORLD:
            # Lay out the action nodes
            x = self.drawActionNodes(layout['action'],x,y,maxRows)
            xPostAction = x
            believer = None
            xkey = 'xpost'
            ykey = 'ypost'
        else:
            believer = agent
            xkey = beliefKey(believer,'xpost')
            ykey = beliefKey(believer,'ypost')
        # Lay out the post variable nodes
        x = self.drawStateNodes(layout['state post'],g,x,y,xkey,ykey,believer,maxRows)
        # Lay out the observation nodes
        if agent == WORLD:
            x = self.drawObservationNodes(x,0,self.graph,xkey,ykey)
        # Lay out the utility nodes
        if agent == WORLD:
            if recursive:
                uNodes = [a.name for a in self.world.agents.values() \
                          if a.getAttribute('beliefs','%s0' % (a.name)) is True]
            else:
                uNodes = self.world.agents.keys()
        else:
            uNodes = [agent]
        x = self.drawUtilityNodes(x,y,g,uNodes)
        if agent == WORLD:
            # Draw links from utility back to actions
            for name in self.world.agents:
                if recursive and \
                   self.world.agents[name].getAttribute('beliefs','%s0' % (name)) is not True:
                    y += (maxRows+1) * self.rowHeight
                    self.displayGroundTruth(name,xPostAction,y,maxRows=maxRows,recursive=recursive)
                if name in g:
                    actions = self.world.agents[name].actions
                    for action in actions:
                        if action in g:
                            if gtnodes and str(action) not in gtnodes:
                                continue
                            self.drawEdge(name,action,g)
            self.colorNodes()
        # Draw links, reusing post nodes as pre nodes
        for key,entry in g.items():
            if isStateKey(key) or isBinaryKey(key):
                if not isFuture(key):
                    key = makeFuture(key)
                if agent != WORLD:
                    key = beliefKey(agent,key)
            elif agent != WORLD:
                continue
            if gtnodes:
                if (isFuture(key) and makePresent(key) not in gtnodes) or (not isFuture(key) and str(key) not in gtnodes):
                    if not isBeliefKey(key):
                        continue
            for child in entry['children']:
                if agent != WORLD and child in self.world.agents and not child in uNodes:
                    continue
                if (isStateKey(child) or isBinaryKey(child)) and agent != WORLD:
                    if isBinaryKey(child) or state2agent(child) == WORLD or \
                       state2feature(child) not in self.world.agents[state2agent(child)].omega:
                        child = beliefKey(agent,child)
                elif agent != WORLD and not child in uNodes:
                    continue
                if child in self.world.agents and not child in uNodes:
                    continue
                if gtnodes and makePresent(child) not in gtnodes:
                    continue
                if selfCycle or key != child:
                    self.drawEdge(key,child,g)
        x += self.colWidth
        if recursive:
            rect = QRectF(-self.colWidth/2,y0-self.rowHeight/2,
                          x,(float(maxRows)+.5)*self.rowHeight)
            self.agents[agent] = {'box': QGraphicsRectItem(rect)}
            self.agents[agent]['box'].setPen(QPen(QBrush(QColor('black')),3))
            self.agents[agent]['box'].setZValue(0.)
            if agent != WORLD:
                self.agents[agent]['text'] = QGraphicsTextItem(self.agents[agent]['box'])
                doc = QTextDocument(agent,self.agents[agent]['text'])
                self.agents[agent]['text'].setPos(rect.x(),rect.y())
                self.agents[agent]['text'].setTextWidth(rect.width())
                self.agents[agent]['text'].setDocument(doc)
            if agent != WORLD:
                color = self.world.diagram.getColor(agent)
                color.setAlpha(128)
                self.agents[agent]['box'].setBrush(QBrush(QColor(color)))
            self.addItem(self.agents[agent]['box'])

        if agent == WORLD:
            for observer in self.world.agents.values():
                if observer.O is not True:
                    for omega,table in observer.O.items():
                        if gtnodes and omega not in gtnodes:
                            continue
                        if self.xml:
                            for oNode in self.xml.nodes():
                                if oNode['label'] == omega:
                                    break
                            else:
                                raise ValueError('Unable to find node for %s' % (omega))
                        for action,tree in table.items():
                            if action is not None:
                                if self.xml and (len(gtnodes) == 0 or str(action) in gtnodes):
                                    for aNode in self.xml.nodes():
                                        if aNode['label'] == str(action):
                                            break
                                    else:
                                        raise ValueError('Unable to find node for %s' % (action))
                                    self.xml.add_edge(aNode,oNode,True)
                            for key in tree.getKeysIn():
                                if key != CONSTANT:
                                    if self.xml:
                                        for sNode in self.xml.nodes():
                                            if sNode['label'] == key:
                                                break
                                        else:
                                            raise ValueError('Unable to find node for %s' % (key))
                                        self.xml.add_edge(sNode,oNode,True)
                                        label = '%sBeliefOf%s' % (observer.name,key)
                                        bNode = self.getGraphNode(label)
                                        self.xml.add_edge(oNode,bNode,True)
                                    if recursive:
                                        belief = beliefKey(observer.name,makeFuture(key))
                                        self.drawEdge(omega,belief)
            for name in self.world.agents:
                # Draw links from non-belief reward components
                model = '%s0' % (name)
                R = self.world.agents[name].getReward(model)
                if R:
                    for parent in R.getKeysIn() - set([CONSTANT]):
                        if beliefKey(name,makeFuture(parent) not in self.nodes['state post']):
                            # Use real variable
                            self.drawEdge(makeFuture(parent),name,g)
            parser = GraphMLParser()
            parser.write(self.xml,'/tmp/GroundTruth-USC.graphml')
Esempio n. 24
0
class WorldView(QGraphicsScene):
    rowHeight = 100
    colWidth = 150
    
    def __init__(self,parent = None):
        super(WorldView,self).__init__(parent)
        self.setBackgroundBrush(QColor('white'))
        self.nodes = {'state pre': {},
                      'state post': {},
                      'action': {},
                      'utility': {},
                      'observation': {}}
        self.edgesOut = {}
        self.edgesIn = {}
        self.agents = {}
        self.world = None
        self.graph = {}
        self.dirty = False
        self.center = None

        self.xml = None

    def clear(self):
        super(WorldView,self).clear()
        for table in self.nodes.values():
            table.clear()
        self.edgesOut.clear()
        self.edgesIn.clear()
        self.center = None
        
    def displayWorld(self,agents=None):
        self.clear()

        self.graph = graph.DependencyGraph(self.world)
        self.graph.computeGraph(agents)
        layout = getLayout(self.graph)

        if self.world.diagram is None:
            self.world.diagram = diagram.Diagram()
        # Lay out the pre variable nodes
        x = self.drawStateNodes(layout['state pre'],self.graph,0,0,'xpre','ypre')
        # Lay out the action nodes
        x = self.drawActionNodes(layout['action'],x,0)
        # Lay out the post variable nodes
        x = self.drawStateNodes(layout['state post'],self.graph,x,0,'xpost','ypost')
        # Lay out the utility nodes
        x = self.drawUtilityNodes(x,0,self.graph,sorted(self.world.agents.keys()))
        self.colorNodes()
        # Lay out edges
        for key,entry in self.graph.items():
            if key in self.nodes[entry['type']]:
                node = self.nodes[entry['type']][key]
                for child in entry['children']:
                    if child in self.nodes[self.graph[child]['type']]:
                        self.drawEdge(key,child)

    def displayGroundTruth(self,agent=WORLD,x0=0,y0=0,maxRows=10,recursive=False,selfCycle=False):
        if agent == WORLD:
            self.clear()
            if __graph__:
                self.xml = Graph()
            else:
                self.xml = None
        
        x = x0
        y = y0
        if agent == WORLD:
            if not self.graph:
                self.graph = graph.DependencyGraph(self.world)
                self.graph.computeGraph()
            g = self.graph
            state = self.world.state
        else:
            g = self.graph = graph.DependencyGraph(self.world)
            state = self.world.agents[agent].getBelief()
            assert len(state) == 1
            g.computeGraph(state=next(iter(state.values())),belief=True)
        layout = getLayout(g)
        if agent == WORLD:
            # Lay out the action nodes
            x = self.drawActionNodes(layout['action'],x,y,maxRows)
            xPostAction = x
            believer = None
            xkey = 'xpost'
            ykey = 'ypost'
        else:
            believer = agent
            xkey = beliefKey(believer,'xpost')
            ykey = beliefKey(believer,'ypost')
        # Lay out the post variable nodes
        x = self.drawStateNodes(layout['state post'],g,x,y,xkey,ykey,believer,maxRows)
        # Lay out the observation nodes
        if agent == WORLD:
            x = self.drawObservationNodes(x,0,self.graph,xkey,ykey)
        # Lay out the utility nodes
        if agent == WORLD:
            if recursive:
                uNodes = [a.name for a in self.world.agents.values() \
                          if a.getAttribute('beliefs','%s0' % (a.name)) is True]
            else:
                uNodes = self.world.agents.keys()
        else:
            uNodes = [agent]
        x = self.drawUtilityNodes(x,y,g,uNodes)
        if agent == WORLD:
            # Draw links from utility back to actions
            for name in self.world.agents:
                if recursive and \
                   self.world.agents[name].getAttribute('beliefs','%s0' % (name)) is not True:
                    y += (maxRows+1) * self.rowHeight
                    self.displayGroundTruth(name,xPostAction,y,maxRows=maxRows,recursive=recursive)
                if name in g:
                    actions = self.world.agents[name].actions
                    for action in actions:
                        if action in g:
                            if gtnodes and str(action) not in gtnodes:
                                continue
                            self.drawEdge(name,action,g)
            self.colorNodes()
        # Draw links, reusing post nodes as pre nodes
        for key,entry in g.items():
            if isStateKey(key) or isBinaryKey(key):
                if not isFuture(key):
                    key = makeFuture(key)
                if agent != WORLD:
                    key = beliefKey(agent,key)
            elif agent != WORLD:
                continue
            if gtnodes:
                if (isFuture(key) and makePresent(key) not in gtnodes) or (not isFuture(key) and str(key) not in gtnodes):
                    if not isBeliefKey(key):
                        continue
            for child in entry['children']:
                if agent != WORLD and child in self.world.agents and not child in uNodes:
                    continue
                if (isStateKey(child) or isBinaryKey(child)) and agent != WORLD:
                    if isBinaryKey(child) or state2agent(child) == WORLD or \
                       state2feature(child) not in self.world.agents[state2agent(child)].omega:
                        child = beliefKey(agent,child)
                elif agent != WORLD and not child in uNodes:
                    continue
                if child in self.world.agents and not child in uNodes:
                    continue
                if gtnodes and makePresent(child) not in gtnodes:
                    continue
                if selfCycle or key != child:
                    self.drawEdge(key,child,g)
        x += self.colWidth
        if recursive:
            rect = QRectF(-self.colWidth/2,y0-self.rowHeight/2,
                          x,(float(maxRows)+.5)*self.rowHeight)
            self.agents[agent] = {'box': QGraphicsRectItem(rect)}
            self.agents[agent]['box'].setPen(QPen(QBrush(QColor('black')),3))
            self.agents[agent]['box'].setZValue(0.)
            if agent != WORLD:
                self.agents[agent]['text'] = QGraphicsTextItem(self.agents[agent]['box'])
                doc = QTextDocument(agent,self.agents[agent]['text'])
                self.agents[agent]['text'].setPos(rect.x(),rect.y())
                self.agents[agent]['text'].setTextWidth(rect.width())
                self.agents[agent]['text'].setDocument(doc)
            if agent != WORLD:
                color = self.world.diagram.getColor(agent)
                color.setAlpha(128)
                self.agents[agent]['box'].setBrush(QBrush(QColor(color)))
            self.addItem(self.agents[agent]['box'])

        if agent == WORLD:
            for observer in self.world.agents.values():
                if observer.O is not True:
                    for omega,table in observer.O.items():
                        if gtnodes and omega not in gtnodes:
                            continue
                        if self.xml:
                            for oNode in self.xml.nodes():
                                if oNode['label'] == omega:
                                    break
                            else:
                                raise ValueError('Unable to find node for %s' % (omega))
                        for action,tree in table.items():
                            if action is not None:
                                if self.xml and (len(gtnodes) == 0 or str(action) in gtnodes):
                                    for aNode in self.xml.nodes():
                                        if aNode['label'] == str(action):
                                            break
                                    else:
                                        raise ValueError('Unable to find node for %s' % (action))
                                    self.xml.add_edge(aNode,oNode,True)
                            for key in tree.getKeysIn():
                                if key != CONSTANT:
                                    if self.xml:
                                        for sNode in self.xml.nodes():
                                            if sNode['label'] == key:
                                                break
                                        else:
                                            raise ValueError('Unable to find node for %s' % (key))
                                        self.xml.add_edge(sNode,oNode,True)
                                        label = '%sBeliefOf%s' % (observer.name,key)
                                        bNode = self.getGraphNode(label)
                                        self.xml.add_edge(oNode,bNode,True)
                                    if recursive:
                                        belief = beliefKey(observer.name,makeFuture(key))
                                        self.drawEdge(omega,belief)
            for name in self.world.agents:
                # Draw links from non-belief reward components
                model = '%s0' % (name)
                R = self.world.agents[name].getReward(model)
                if R:
                    for parent in R.getKeysIn() - set([CONSTANT]):
                        if beliefKey(name,makeFuture(parent) not in self.nodes['state post']):
                            # Use real variable
                            self.drawEdge(makeFuture(parent),name,g)
            parser = GraphMLParser()
            parser.write(self.xml,'/tmp/GroundTruth-USC.graphml')

    def getGraphNode(self,label):
        for node in self.xml.nodes():
            if node['label'] == label:
                return node
        else:
            return(self.xml.add_node(label))
        
    def drawStateNodes(self,nodes,graph,x0,y0,xkey,ykey,believer=None,maxRows=10):
        x = x0
        even = True
        for layer in nodes:
            y = y0
            for key in sorted(layer):
                if believer:
                    label = beliefKey(believer,key)
                    if self.xml:
                        self.xml.add_node('%sBeliefOf%s' % (believer,makePresent(key)))
                else:
                    if gtnodes and makePresent(key) not in gtnodes:
                        continue
                    label = key
                    if self.xml:
                        self.xml.add_node(makePresent(key))
                variable = self.world.variables[makePresent(key)]
                if y >= y0+maxRows*self.rowHeight:
                    even = not even
                    if even:
                        y = y0
                    else:
                        y = y0+50
                    x += int(0.75*self.colWidth)
                if not xkey in variable:
                    variable[xkey] = x
                    variable[ykey] = y
                # Move on to next Y
                y += self.rowHeight
                if graph[key]['agent'] != WORLD and graph[key]['agent']:
                    agent = self.world.agents[graph[key]['agent']]
                    if isBinaryKey(key):
                        node = VariableNode(agent,key[len(agent.name)+1:],label,
                                            variable[xkey],variable[ykey],
                                            100,50,scene=self)
                    else:
                        node = VariableNode(agent,key[len(agent.name)+3:],label,
                                            variable[xkey],variable[ykey],
                                            100,50,scene=self)
                else:
                    node = VariableNode(None,state2feature(key),key,
                                        variable[xkey],variable[ykey],
                                        100,50,scene=self)
                self.nodes[graph[key]['type']][label] = node
            x += self.colWidth
        return x

    def drawActionNodes(self,nodes,x0,y0,maxRows=10):
        x = x0
        y = y0
        for action in sorted(nodes):
            if gtnodes and str(action) not in gtnodes:
                continue
            if self.world.diagram.getX(action) is None:
                self.setDirty()
                self.world.diagram.x[action] = x
                self.world.diagram.y[action] = y
                # Move on to next Y
                y += self.rowHeight
                if y >= maxRows*self.rowHeight:
                    y = y0
                    x += self.colWidth
            else:
                x = max(x,self.world.diagram.getX(action))
                y = max(y,self.world.diagram.getY(action))
            node = ActionNode(self.world.agents[self.graph[action]['agent']],action,scene=self)
            self.nodes[self.graph[action]['type']][action] = node
            if self.xml:
                self.xml.add_node(str(action))
        x += self.colWidth
        return x

    def drawUtilityNodes(self,x0,y0,graph,agents):
        x = x0
        y = y0 - self.rowHeight/2
        for name in agents:
            if name in graph:
                agent = self.world.agents[name]
                if self.world.diagram.getX(agent.name) is None:
                    self.setDirty()
                    y += self.rowHeight
                    self.world.diagram.x[agent.name] = x
                    self.world.diagram.y[agent.name] = y
                else:
                    x = self.world.diagram.getX(agent.name)
                    y = self.world.diagram.getY(agent.name)
                node = UtilityNode(agent,x,y,scene=self)
                self.nodes[graph[name]['type']][name] = node
                if self.xml:
                    self.xml.add_node(name)
                if self.xml:
                    self.xml.add_edge(self.getGraphNode(stateKey(name,'horizon')),
                                      self.getGraphNode(name),True)
        x += self.colWidth
        return x

    def drawObservationNodes(self,x0,y0,graph,xkey,ykey,believer=None,maxRows=10):
        omega = sorted(sum([[stateKey(name,omega) for omega in self.world.agents[name].omega]
                            for name in self.world.agents],[]))
        x = x0
        y = y0
        even = True
        oNodes = {}
        for key in omega:
            if gtnodes and makePresent(key) not in gtnodes:
                continue
            if believer:
                label = beliefKey(believer,key)
                if self.xml:
                    self.xml.add_node('%sBeliefOf%s' % (believer,makePresent(key)))
            else:
                label = key
                if self.xml:
                    oNodes[key] = self.xml.add_node(key)
            variable = self.world.variables[makePresent(key)]
            if y >= y0+maxRows*self.rowHeight:
                even = not even
                if even:
                    y = y0
                else:
                    y = y0+50
                x += int(0.75*self.colWidth)
            if not xkey in variable:
                variable[xkey] = x
                variable[ykey] = y
            # Move on to next Y
            y += self.rowHeight
            agent = self.world.agents[state2agent(key)]
            if isBinaryKey(key):
                node = VariableNode(agent,key[len(agent.name)+1:],key,
                                    variable[xkey],variable[ykey],
                                    100,50,scene=self)
            else:
                node = VariableNode(agent,key[len(agent.name)+3:],key,
                                    variable[xkey],variable[ykey],
                                    100,50,scene=self)
            self.nodes['observation'][label] = node
        x += self.colWidth
        return x
        
    def drawEdge(self,parent,child,graph=None,rect0=None,rect1=None):
        if self.xml:
            if isinstance(parent,str):
                parentVal = makePresent(parent)
            else:
                parentVal = str(parent)
            if isBeliefKey(parentVal):
                parentVal = '%sBeliefOf%s' % (belief2believer(parentVal),
                                              makePresent(belief2key(parentVal)))
            if isinstance(child,str):
                childVal = makePresent(child)
            else:
                childVal = str(child)
            if isBeliefKey(childVal):
                childVal = '%sBeliefOf%s' % (belief2believer(childVal),
                                             makePresent(belief2key(childVal)))
            for nP in self.xml.nodes():
                if nP['label'] == str(parentVal):
                    break
            else:
                raise RuntimeError('Unable to find GraphML node %s' % (parentVal))
            for nC in self.xml.nodes():
                if nC['label'] == str(childVal):
                    break
            else:
                raise RuntimeError('Unable to find GraphML node %s (link from %s)' % \
                                   (childVal,parentVal))
            self.xml.add_edge(nP,nC,True)
        if graph is None:
            graph = self.graph
        if isBeliefKey(parent):
            node0 = self.nodes[graph[belief2key(parent)]['type']][parent]
        else:
            node0 = self.nodes[graph[parent]['type']][parent]
        if isBeliefKey(child):
            node1 = self.nodes[graph[belief2key(child)]['type']][child]
        else:
            node1 = self.nodes[graph[child]['type']][child]
        if rect0 is None:
            rect0 = node0.boundingRect()
        if rect1 is None:
            rect1 = node1.boundingRect()
        if parent == child:
            # Loop back to self
            x0 = rect0.x()+rect0.width()/15
            y0 = rect0.y()+2*rect0.height()/3
            path = QPainterPath(QPointF(x0,y0))
            path.arcTo(rect0.x(),rect0.y()+rect0.height()/2,rect0.width(),rect0.height(),145,250)
            edge = QGraphicsPathItem(path,node0)
            arrow = drawArrow(QLineF(x0-5,y0+25,x0,y0),edge)
        elif rect0.y() == rect1.y():
            # Same row, so arc
            x0 = rect0.x()+rect0.width()/2
            x1 = rect1.x()+rect1.width()/2
            path = QPainterPath(QPointF(x1,rect1.y()+rect1.height()/2))
            path.arcTo(x1,rect1.y()+rect1.height()/2,x0-x1,rect1.height(),180,180)
            edge = QGraphicsPathItem(path)
            node0.scene().addItem(edge)
            if x1 < x0:
                arrow = drawArrow(QLineF(x1+25,rect1.y()+rect1.height()+15,
                                         x1-5,rect1.y()+rect1.height()),edge)
            else:
                arrow = drawArrow(QLineF(x1-25,rect1.y()+rect1.height()+15,
                                         x1+5,rect1.y()+rect1.height()),edge)
        else:
            # straight-line link
            if rect0.x() < rect1.x():
                x0 = rect0.right()
                x1 = rect1.left()
            else:
                x0 = rect0.left()
                x1 = rect1.right()
            y0 = rect0.y()+rect0.height()/2
            y1 = rect1.y()+rect1.height()/2
            edge = QGraphicsLineItem(x0,y0,x1,y1)
            node0.scene().addItem(edge)
            arrow = drawArrow(edge.line(),edge)

        edge.setZValue(1.)
        if not parent in self.edgesOut:
            self.edgesOut[parent] = {}
        if child in self.edgesOut[parent]:
            node0.scene().removeItem(self.edgesOut[parent][child][0])
        self.edgesOut[parent][child] = (edge,arrow)
        if not child in self.edgesIn:
            self.edgesIn[child] = {}
        if parent != child:
            self.edgesIn[child][parent] = (edge,arrow)
        return edge

    def highlightEdges(self,center):
        """
        Hide any edges *not* originating or ending at the named node
        :type center: {str}
        """
        self.center = center
        for key,table in list(self.edgesOut.items())+list(self.edgesIn.items()):
            if center is None or key in center:
                # All edges are important!
                for edge,arrow in table.values():
                    edge.show()
            else:
                for subkey,(edge,arrow) in table.items():
                    if center is None or subkey in center:
                        # This edge is important
                        edge.show()
                    else:
                        # This edge is unimportant
                        edge.hide()
                        
    def boldEdges(self,center):
        """
        Highlight any edges originating or ending at the named node
        :type center: {str}
        """
        for key,table in self.edgesOut.items()+self.edgesIn.items():
            if key in center:
                # All edges are important!
                for edge,arrow in table.values():
                    edge.setPen(QPen(QBrush(QColor('black')),5))
                    edge.setZValue(2.0)
            else:
                for subkey,(edge,arrow) in table.items():
                    if subkey in center:
                        # This edge is important
                        edge.setPen(QPen(QBrush(QColor('black')),5))
                        edge.setZValue(2.0)
                    else:
                        # This edge is unimportant
                        edge.setPen(QPen(QColor('black')))
                        edge.setZValue(1.0)

    def updateEdges(self,key,rect):
        self.setDirty()
        if key in self.edgesOut:
            for subkey,(edge,arrow) in self.edgesOut[key].items():
                if self.center is None or key in self.center or subkey in self.center:
                    if isinstance(edge,QGraphicsLineItem):
                        line = edge.line()
                        line.setP1(QPointF(rect.x()+rect.width(),rect.y()+rect.height()/2))
                        edge.setLine(line)
                        drawArrow(line,arrow=arrow)
                    elif key != subkey:
                        edge.scene().removeItem(edge)
                        del self.edgesOut[key][subkey]
                        del self.edgesIn[subkey][key]
                        self.drawEdge(key,subkey,rect0=rect)
        if key in self.edgesIn:
            for subkey,(edge,arrow) in self.edgesIn[key].items():
                if self.center is None or key in self.center or subkey in self.center:
                    if isinstance(edge,QGraphicsLineItem):
                        line = edge.line()
                        line.setP2(QPointF(rect.x(),rect.y()+rect.height()/2))
                        edge.setLine(line)
                        drawArrow(line,arrow=arrow)
                    elif key != subkey:
                        edge.scene().removeItem(edge)
                        del self.edgesIn[key][subkey]
                        del self.edgesOut[subkey][key]
                        self.drawEdge(subkey,key,rect1=rect)

    def step(self):
        self.world.step()
        self.world.printState()
        self.colorNodes('likelihood')
        
    def colorNodes(self,mode='agent'):
        cache = None
        for category,nodes in self.nodes.items():
            for node in nodes.values():
                color = node.defaultColor
                if mode == 'agent':
                    if node.agent:
                        color = self.world.diagram.getColor(node.agent.name)
                    elif node.agent is None:
                        color = self.world.diagram.getColor(None)
                elif mode == 'likelihood':
                    if cache is None:
                        # Pre-compute some outcomes
                        cache = {}
                        outcomes = self.world.step(real=False)
                        for outcome in outcomes:
                            # Update action probabilities
                            for name,distribution in outcome['actions'].items():
                                if name not in cache:
                                    cache[name] = Distribution()
                                for action in distribution.domain():
                                    cache[name].addProb(action,outcome['probability']*distribution[action])
                            # Update state probabilities
                            for vector in outcome['new'].domain():
                                for key,value in vector.items():
                                    if key not in cache:
                                        cache[key] = Distribution()
                                    cache[key].addProb(value,outcome['probability']*outcome['new'][vector])
                    if category == 'state pre':
                        if node.agent:
                            key = stateKey(node.agent.name,node.feature)
                        else:
                            key = stateKey(None,node.feature)
                        variable = self.world.variables[key]
                        marginal = self.world.getFeature(key)
                        if variable['domain'] is bool:
                            color = dist2color(marginal)
                        else:
                            raise RuntimeError('Unable to display color of %s over domain %s' % (key,variable['domain']))
                    elif category == 'action':
                        uniform = 1./float(len(cache[node.agent.name]))
                        prob = cache[node.agent.name].getProb(node.action)
                        if prob < uniform:
                            prob = 0.5*prob/uniform
                        else:
                            prob = 0.5*(prob-uniform)/(1.-uniform) + 0.5
                        distribution = Distribution({True: prob})
                        distribution[False] = 1.-distribution[True]
                        color = dist2color(distribution)
                    elif category == 'state post':
                        if node.agent:
                            key = stateKey(node.agent.name,node.feature)
                        else:
                            key = stateKey(None,node.feature)
                        key = makePresent(key)
                        if self.world.variables[key]['domain'] is bool:
                            dist = self.world.float2value(key,cache[key])
                            color = dist2color(dist)
                node.setBrush(QBrush(color))

    def setDirty(self):
        self.parent().parent().parent().actionSave.setEnabled(True)
        self.dirty = True

    def unsetDirty(self):
        self.parent().parent().parent().actionSave.setEnabled(False)
        self.dirty = False

    def minRect(self):
        """
        @return: a rectangle cropped to show only object space
        """
        rect = None
        for nodes in self.nodes.values():
            for node in nodes.values():
                if rect is None:
                    rect = node.boundingRect()
                else:
                    rect = rect.united(node.boundingRect())
        return rect

    def saveImage(self,fname):
        rect = self.minRect() #self.sceneRect()
        pix = QImage(rect.width(), rect.height(),QImage.Format_ARGB32)
        painter = QPainter(pix)
        self.render(painter,rect)
        painter.end()
        pix.save(fname)

    def saveSubgraphs(self,dirName,onlyConnected=True):
        previous = self.center
        for nodeType,nodes in self.nodes.items():
            for key,node in nodes.items():
                if not onlyConnected or key in self.edgesOut or key in self.edgesIn:
                    center = {key}
                    if nodeType == 'state post':
                        for agent in self.world.agents:
                            subkey = beliefKey(agent,key)
                            if subkey in nodes:
                                center.add(subkey)
                    self.highlightEdges(center)
                    if isinstance(key,ActionSet):
                        self.saveImage(os.path.join(dirName,'%s.png' % (str(key))))
                    else:
                        self.saveImage(os.path.join(dirName,'%s.png' % (escapeKey(key))))
        self.highlightEdges(previous)
Esempio n. 25
0
class Property_Graph:
    def __init__(self):
        """
        Initializes graph parameters.
        """
        self.g = Graph()
        self.vertex_id = 0
        self.edge_id = 0

    def add_vertex(self, label, value, property=None):
        """
        Adds a vertex to the graph.

        @param label: default label or key by which vertex is to be 
            added (vertex will be uniquely by this label and its value) e.g. "name"
        @param value: value of above label e.g. "product0012"
        @param property: list of length 2 containing key name of property as first element
            and value of property as second element
        """

        # check if node with same label already exists, if it does then return that node instance
        for n in self.g._nodes:
            if n[label] == value:
                return n

        # add new node to graph
        node = self.g.add_node(str(self.vertex_id))
        # add default label and its value
        node[label] = value
        # add additional properties if provided
        if property != None:
            node[property[0]] = property[1]
        self.vertex_id += 1
        return node

    def add_edge(self,
                 label,
                 label_value1,
                 label_value2,
                 default_property,
                 property=None):
        """
        Adds edge between two vertices.

        @param label: label or key value by which vertex will be searched e.g. "name" or "URI"
        @param label_value1 : value of above label or key of source vertex
        @param label_value2 : value of above label or key of target vertex
        @param default_property : default_property of edge (predicate in RDF terms)
        @param property : additional property, list of length 2 containing key name of property 
            as first element and value of property as second element
        """
        n1 = None
        n2 = None

        # Search source and target nodes
        for n in self.g._nodes:
            if n[label] == label_value1:
                n1 = n
            if n[label] == label_value2:
                n2 = n

        # If source or target doesn't exists, then return
        if n1 == None or n2 == None:
            return

        # Add edge
        edge = self.g.add_edge(n1, n2, directed=True)
        # Add edge default property
        edge['property'] = default_property
        edge['id'] = str(self.edge_id)
        # Add additional property if provided
        if property != None:
            edge[property[0]] = edge[property[1]]
        self.edge_id += 1


    def add_vertices_and_edge(self, label, label_value1, label_value2, default_edge_property,\
         edge_property=None, vertex1_property=None, vertex2_property=None):
        """
        Adds two vertices and edge connecting them

        @param label: default label or key by which vertex is to be 
            added (vertex will be uniquely by this label and its value) e.g. "name"
        @param label_value1 : value of above label or key of source vertex
        @param label_value2 : value of above label or key of target vertex
        @param default_edge_property : default_property of edge (predicate in RDF terms)
        @param edge_property : additional property, list of length 2 containing key name of property 
            as first element and value of property as second element
        @param vertex1_property: list of length 2 containing key name of property as first element
            and value of property as second element
        @param vertex2_property: list of length 2 containing key name of property as first element
            and value of property as second element
        """
        n1 = self.add_vertex(label, label_value1, vertex1_property)
        n2 = self.add_vertex(label, label_value2, vertex2_property)
        edge = self.g.add_edge(n1, n2, directed=True)
        edge['label'] = default_edge_property
        edge['id'] = str(self.edge_id)
        self.edge_id += 1
        if edge_property != None:
            edge[edge_property[0]] = edge[edge_property[1]]

    def add_property(self, label, label_value, property, to_edge=False):
        """
        Adds property to a edge or vertex 
        
        @param label : label or key by which desired edge or vertex will be searched
        @param label_value : value of above label or key
        @param property : property to be added, list of length 2 containing key name of 
            property as first element and value of property as second element
        @param to_edge : If set True, property will be added to edge, default value is False. 
        """
        if to_edge:
            # Yet to be implemented
            pass
        else:

            for n in self.g._nodes:
                if n[label] == label_value:
                    n[property[0]] = property[1]
                    break

    def save_graph(self, file_name):
        """
        Save graph to .graphml file

        @param file_name : name of the file to which graph will be saved
        """
        parser = GraphMLParser()
        parser.write(self.g, file_name)
Esempio n. 26
0
# Radiation grid from CSCI 6550 HW 1

from pygraphml import Graph, GraphMLParser

radiation = Graph()

two = radiation.add_node("2")
three = radiation.add_node("3")
four = radiation.add_node("4")
six = radiation.add_node("6")
seven = radiation.add_node("7")
nine = radiation.add_node("9")
ten = radiation.add_node("10")
eleven = radiation.add_node("11")
twelve = radiation.add_node("12")
thirteen = radiation.add_node("13")
fourteen = radiation.add_node("14")
fifteen = radiation.add_node("15")

edge = radiation.add_edge(two, three, directed=True)
edge['weight'] = 9
edge = radiation.add_edge(two, six, directed=True)
edge['weight'] = 11

edge = radiation.add_edge(three, two, directed=True)
edge['weight'] = 9
edge = radiation.add_edge(three, four, directed=True)
edge['weight'] = 10
edge = radiation.add_edge(three, seven, directed=True)
edge['weight'] = 11
Esempio n. 27
0
# basic binary tree with all edge weights = 1

from pygraphml import Graph, GraphMLParser

test1 = Graph()

a = test1.add_node("A")
b = test1.add_node("B")
c = test1.add_node("C")
d = test1.add_node("D")
e = test1.add_node("E")
f = test1.add_node("F")
g = test1.add_node("G")
h = test1.add_node("H")
i = test1.add_node("I")
j = test1.add_node("J")
k = test1.add_node("K")
l = test1.add_node("L")
m = test1.add_node("M")
n = test1.add_node("N")
o = test1.add_node("O")

test1.add_edge(a, b, directed=True)
test1.add_edge(a, c, directed=True)
test1.add_edge(b, d, directed=True)
test1.add_edge(b, e, directed=True)
test1.add_edge(c, f, directed=True)
test1.add_edge(c, g, directed=True)
test1.add_edge(d, h, directed=True)
test1.add_edge(d, i, directed=True)
test1.add_edge(e, j, directed=True)
Esempio n. 28
0
from pygraphml.GraphMLParser import *
from pygraphml.Graph import *
from pygraphml.Node import *
from pygraphml.Edge import *

import sys

# parser = GraphMLParser()
# g = parser.parse(sys.argv[1])

# root = g.set_root_by_attribute("RootNode")
# #print g.root()

# for n in g.DFS_prefix():
#     print n

# #g.show(True)

g = Graph()

n1 = g.add_node("salut")
n2 = g.add_node("coucou")
n1['positionX'] = 555

g.add_edge(n1, n2)

parser = GraphMLParser()
parser.write(g, "ttest.graphml")

#g.show()
Esempio n. 29
0
        super().__init__(graph)
        self.W = W
        self._process()


if __name__ == '__main__':
    parser = argparse.ArgumentParser('A small graph vizualization tool')
    parser.add_argument(
        '--input',
        help='input file (currently works only with graphml format)',
        required=True)
    parser.add_argument('--output',
                        help='result (given FNAME, creates files '
                        '"FNAME" with graph representation in dot format and '
                        '"FNAME.png" with a picture',
                        default='graph')
    parser.add_argument('--alg', help='vizualization algorithm', required=True)
    parser.add_argument('--params', help='algo parameters', default='{}')
    args = parser.parse_args()

    algo_params = json.loads(args.params)
    graph = Graph.from_graphml(args.input)
    if args.alg == 'layered-tree':
        drawer = LayeredTreeDrawer(RootedTree(graph))
    elif args.alg == 'coffman-graham':
        drawer = CoffmanGrahamDrawer(
            DAG(graph),
            W=0 if 'W' not in algo_params else algo_params['W'],
        )
    drawer.dot_draw(args.output)