334 lines
11 KiB
Python
334 lines
11 KiB
Python
#!/usr/bin/python
|
|
##############################################################################
|
|
#
|
|
# Copyright (c) 2004-2008 Tiny SPRL (http://tiny.be) All Rights Reserved.
|
|
#
|
|
# $Id$
|
|
#
|
|
# WARNING: This program as such is intended to be used by professional
|
|
# programmers who take the whole responsability of assessing all potential
|
|
# consequences resulting from its eventual inadequacies and bugs
|
|
# End users who are looking for a ready-to-use solution with commercial
|
|
# garantees and support are strongly adviced to contract a Free Software
|
|
# Service Company
|
|
#
|
|
# This program is Free Software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License
|
|
# as published by the Free Software Foundation; either version 2
|
|
# of the License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
###############################################################################
|
|
|
|
class graph(object):
|
|
def __init__(self, nodes, transitions):
|
|
self.nodes = nodes
|
|
self.links = transitions
|
|
trans = {}
|
|
for t in transitions:
|
|
trans.setdefault(t[0], [])
|
|
trans[t[0]].append(t[1])
|
|
self.transitions = trans
|
|
self.result = {}
|
|
self.levels = {}
|
|
|
|
def get_parent(self,node):
|
|
count = 0
|
|
for item in self.transitions:
|
|
if self.transitions[item].__contains__(node):
|
|
count +=1
|
|
return count
|
|
|
|
def init_rank(self):
|
|
self.temp = {}
|
|
for link in self.links:
|
|
self.temp[link] = self.result[link[1]]['y'] - self.result[link[0]]['y']
|
|
|
|
cnt = 0
|
|
list_node = []
|
|
list_edge = []
|
|
|
|
while self.tight_tree()<self.result.__len__():
|
|
cnt+=1
|
|
list_node = []
|
|
|
|
for node in self.nodes:
|
|
if node not in self.reachable_nodes:
|
|
list_node.append(node)
|
|
list_edge = []
|
|
|
|
for link in self.temp:
|
|
if link not in self.tree_edges:
|
|
list_edge.append(link)
|
|
|
|
slack = 100
|
|
|
|
for edge in list_edge:
|
|
if (self.reachable_nodes.__contains__(edge[0]) and edge[1] not in self.reachable_nodes) or ( self.reachable_nodes.__contains__(edge[1]) and edge[0] not in self.reachable_nodes):
|
|
if(slack>self.temp[edge]-1):
|
|
slack = self.temp[edge]-1
|
|
new_edge = edge
|
|
|
|
if new_edge[0] not in self.reachable_nodes:
|
|
delta = -(self.temp[new_edge]-1)
|
|
else:
|
|
delta = self.temp[new_edge]-1
|
|
|
|
for node in self.result:
|
|
if node in self.reachable_nodes:
|
|
self.result[node]['y'] += delta
|
|
|
|
for link in self.temp:
|
|
self.temp[link] = self.result[link[1]]['y'] - self.result[link[0]]['y']
|
|
|
|
self.init_cutvalues()
|
|
|
|
|
|
|
|
|
|
def tight_tree(self,):
|
|
self.reachable_nodes = []
|
|
self.tree_edges = []
|
|
self.reachable_node(self.start)
|
|
return self.reachable_nodes.__len__()
|
|
|
|
def reachable_node(self,node):
|
|
if node not in self.reachable_nodes:
|
|
self.reachable_nodes.append(node)
|
|
for link in self.temp:
|
|
if link[0]==node:
|
|
# print link[0]
|
|
if self.temp[link]==1:
|
|
self.tree_edges.append(link)
|
|
if link[1] not in self.reachable_nodes:
|
|
self.reachable_nodes.append(link[1])
|
|
self.reachable_node(link[1])
|
|
|
|
|
|
def init_cutvalues(self):
|
|
self.cut_edges = {}
|
|
self.head_nodes = []
|
|
i=0;
|
|
for edge in self.tree_edges:
|
|
self.head_nodes = []
|
|
rest_edges = []
|
|
rest_edges += self.tree_edges
|
|
rest_edges.__delitem__(i)
|
|
self.head_component(self.start,rest_edges)
|
|
i+=1
|
|
positive = 0
|
|
negative = 0
|
|
for source_node in self.transitions:
|
|
if source_node in self.head_nodes:
|
|
for dest_node in self.transitions[source_node]:
|
|
if dest_node not in self.head_nodes:
|
|
negative+=1
|
|
else:
|
|
for dest_node in self.transitions[source_node]:
|
|
if dest_node in self.head_nodes:
|
|
positive+=1
|
|
|
|
self.cut_edges[edge] = positive - negative
|
|
|
|
|
|
|
|
|
|
def head_component(self, node, rest_edges):
|
|
if node not in self.head_nodes:
|
|
self.head_nodes.append(node)
|
|
for link in rest_edges:
|
|
if link[0]==node:
|
|
self.head_component(link[1],rest_edges)
|
|
|
|
|
|
def process_ranking(self, node, level=0):
|
|
if node not in self.result:
|
|
self.result[node] = {'x': None, 'y':level, 'mark':0}
|
|
else:
|
|
if level > self.result[node]['y']:
|
|
self.result[node]['y'] = level
|
|
if self.result[node]['mark']==0:
|
|
self.result[node]['mark'] = 1
|
|
for t in self.transitions.get(node, []):
|
|
self.process_ranking(t, level+1)
|
|
|
|
|
|
def preprocess_order(self):
|
|
levels = {}
|
|
for r in self.result:
|
|
l = self.result[r]['y']
|
|
levels.setdefault(l,[])
|
|
levels[l].append(r)
|
|
self.levels = levels
|
|
|
|
def process_order(self, level):
|
|
self.levels[level].sort(lambda x,y: cmp(self.result[x]['x'], self.result[y]['x']))
|
|
for nodepos in range(len(self.levels[level])):
|
|
node = self.levels[level][nodepos]
|
|
if nodepos == 0:
|
|
left = self.result[node]['x']- 0.5
|
|
else:
|
|
left = (self.result[node]['x'] + self.result[self.levels[level][nodepos-1]]['x']) / 2.0
|
|
|
|
if nodepos == (len(self.levels[level])-1):
|
|
right = self.result[node]['x'] + 0.5
|
|
else:
|
|
right = (self.result[node]['x'] + self.result[self.levels[level][nodepos+1]]['x']) / 2.0
|
|
|
|
|
|
if self.transitions.get(node, False):
|
|
if len(self.transitions[node])==1:
|
|
pos = (left+right)/2.0
|
|
step = 0
|
|
else:
|
|
pos = left
|
|
step = (-left+right) / (len(self.transitions[node])-1)
|
|
|
|
for n2 in self.transitions[node]:
|
|
self.result[n2]['x'] = pos
|
|
pos += step
|
|
|
|
def exchange(self,e,f):
|
|
self.tree_edges.__delitem__(self.tree_edges.index(e))
|
|
self.tree_edges.append(f)
|
|
self.init_cutvalues()
|
|
|
|
|
|
def enter_edge(self,edge):
|
|
self.head_nodes = []
|
|
rest_edges = []
|
|
rest_edges += self.tree_edges
|
|
rest_edges.__delitem__(rest_edges.index(edge))
|
|
self.head_component(self.start,rest_edges)
|
|
slack = 100
|
|
for source_node in self.transitions:
|
|
if source_node in self.head_nodes:
|
|
for dest_node in self.transitions[source_node]:
|
|
if dest_node not in self.head_nodes:
|
|
if(slack>(self.temp[edge]-1)):
|
|
slack = self.temp[edge]-1
|
|
new_edge = (source_node,dest_node)
|
|
return new_edge
|
|
|
|
|
|
def leave_edge(self):
|
|
for edge in self.cut_edges:
|
|
if self.cut_edges[edge]<0:
|
|
return edge
|
|
return ()
|
|
|
|
def process(self, starting_node):
|
|
pos = (len(starting_node) - 1.0)/2.0
|
|
self.start = starting_node[0]
|
|
for s in starting_node:
|
|
self.process_ranking(s)
|
|
self.result[s]['x'] = pos
|
|
pos += 1.0
|
|
self.init_rank()
|
|
#normalize
|
|
least_rank=100
|
|
|
|
#normalization
|
|
for node in self.result:
|
|
if least_rank>self.result[node]['y']:
|
|
least_rank = self.result[node]['y']
|
|
|
|
if(least_rank!=0):
|
|
diff = least_rank
|
|
for node in self.result:
|
|
self.result[node]['y']-=least_rank
|
|
|
|
e = self.leave_edge()
|
|
#while e:
|
|
f = self.enter_edge(e)
|
|
self.exchange(e,f)
|
|
e = self.leave_edge()
|
|
|
|
|
|
|
|
self.preprocess_order()
|
|
for n in self.levels:
|
|
self.process_order(n)
|
|
|
|
|
|
|
|
|
|
def __str__(self):
|
|
result = ''
|
|
for l in self.levels:
|
|
result += 'PosY: ' + str(l) + '\n'
|
|
for node in self.levels[l]:
|
|
result += '\tPosX: '+ str(self.result[node]['x']) + ' - Node:' + node + "\n"
|
|
return result
|
|
|
|
def scale(self, maxx, maxy, plusx2=0, plusy2=0):
|
|
plusx = - min(map(lambda x: x['x'],self.result.values()))
|
|
plusy = - min(map(lambda x: x['y'],self.result.values()))
|
|
|
|
maxcurrent = 1.0
|
|
diff = 1.0
|
|
for l in self.levels:
|
|
for n in range(1, len(self.levels[l])):
|
|
n1 = self.levels[l][n]
|
|
n2 = self.levels[l][n-1]
|
|
diff = abs(self.result[n2]['x']-self.result[n1]['x'])
|
|
if diff<maxcurrent:
|
|
maxcurrent=diff
|
|
factor = maxx / diff
|
|
for r in self.result:
|
|
self.result[r]['x'] = (self.result[r]['x']+plusx) * factor + plusx2
|
|
self.result[r]['y'] = (self.result[r]['y']+plusy) * maxy + plusy2
|
|
|
|
def result_get(self):
|
|
return self.result
|
|
|
|
if __name__=='__main__':
|
|
starting_node = ['profile'] # put here nodes with flow_start=True
|
|
nodes = ['project','account','hr','base','product','mrp','test','profile']
|
|
transitions = [
|
|
('profile','mrp'),
|
|
('mrp','project'),
|
|
('project','product'),
|
|
('mrp','hr'),
|
|
('mrp','test'),
|
|
('project','account'),
|
|
('project','hr'),
|
|
('product','base'),
|
|
('account','product'),
|
|
('account','test'),
|
|
('account','base'),
|
|
('hr','base'),
|
|
('test','base')
|
|
]
|
|
|
|
radius = 20
|
|
g = graph(nodes, transitions)
|
|
g.process(starting_node)
|
|
g.scale(radius*3,radius*3, radius, radius)
|
|
|
|
print g
|
|
|
|
import Image
|
|
import ImageDraw
|
|
img = Image.new("RGB", (800, 600), "#ffffff")
|
|
draw = ImageDraw.Draw(img)
|
|
|
|
for name,node in g.result.items():
|
|
draw.arc( (int(node['x']-radius), int(node['y']-radius),int(node['x']+radius), int(node['y']+radius) ), 0, 360, (128,128,128))
|
|
draw.text( (int(node['x']), int(node['y'])), name, (128,128,128))
|
|
|
|
|
|
for nodefrom in g.transitions:
|
|
for nodeto in g.transitions[nodefrom]:
|
|
draw.line( (int(g.result[nodefrom]['x']), int(g.result[nodefrom]['y']),int(g.result[nodeto]['x']),int(g.result[nodeto]['y'])),(128,128,128) )
|
|
|
|
img.save("graph.png", "PNG")
|
|
|