def __init__(self, site_url, backup=None):
self.site_url = site_url
self.data = self.get_backup(backup) if backup else {}
self.graph_post = tlp.newGraph()
self.graph_user = tlp.newGraph()
self.viewLabelPost = self.graph_post.getStringProperty("viewLabel")
self.viewLabelUser = self.graph_user.getStringProperty("viewLabel")
os.makedirs('dataset', exist_ok=True)
def forest(graph, roots=()):
res = tlp.newGraph()
equiv = {}
for node in graph.getNodes():
new_node = res.addNode()
equiv[node] = new_node
for n in graph.getNodes():
graph['visited'][n] = False
def visit(graph, n):
if not graph['visited'][n]:
graph['visited'][n] = True
path = [n]
branches = [graph.getOutNodes(n)]
while branches:
if branches[-1].hasNext():
succ = branches[-1].next()
if not graph['visited'][succ]:
res.addEdge(equiv[path[-1]], equiv[succ])
graph['visited'][succ] = True
path.append(succ)
branches.append(graph.getOutNodes(succ))
else:
path.pop()
branches.pop()
for n in roots:
visit(graph, n)
for n in graph.getNodes():
visit(graph, n)
return res, equiv
def mspl(filter_function=host.scripts.utils.filter_function_simple,
label_generator=label_generator_simple,
keep_self_loop=False):
graph = tlp.newGraph()
spl_nodes = {}
for spl in hyportage_db.mspl.itervalues():
if filter_function(spl):
node = graph.addNode()
spl_nodes[spl] = node
graph['viewLabel'][node] = label_generator(spl)
spls = set(spl_nodes.keys())
for spl, node in spl_nodes.iteritems():
dependency_list = {
dep
for pattern in spl.dependencies.iterkeys()
for dep in hyportage_pattern.pattern_repository_get(
hyportage_db.pattern_repository, pattern).matched_spls(
hyportage_db.mspl, hyportage_db.spl_groups)
}
for dep in dependency_list & spls:
if keep_self_loop or (spl != dep):
graph.addEdge(spl_nodes[spl], spl_nodes[dep])
return graph, spl_nodes
def spl_groups(filter_function=host.scripts.utils.filter_function_simple,
label_generator=label_generator_simple,
keep_self_loop=False):
graph = tlp.newGraph()
group_nodes = {}
for group in hyportage_db.spl_groups.itervalues():
if filter_function(group):
node = graph.addNode()
group_nodes[group] = node
graph['viewLabel'][node] = label_generator(group)
groups = set(group_nodes.keys())
for group, node in group_nodes.iteritems():
dependency_list = {
dep
for spl in group.references
for pattern in spl.dependencies.iterkeys()
for dep in hyportage_pattern.pattern_repository_get(
hyportage_db.pattern_repository, pattern).matched_spls(
hyportage_db.mspl, hyportage_db.spl_groups)
}
group_dependency_list = {
hyportage_db.spl_groups[hyportage_data.spl_get_group_name(spl)]
for spl in dependency_list
}
for dep in group_dependency_list & groups:
if keep_self_loop or (group != dep):
graph.addEdge(group_nodes[group], group_nodes[dep])
return graph, group_nodes
def load_csv_to_tulip(csvfilename):
graph = None
with open(csvfilename, 'r') as fp:
graph = tlp.newGraph()
nodes = []
line_no = 0
for line in fp:
if line_no == 0:
ids = map(lambda s: s.strip(), filter(lambda s: len(s) > 0, line.strip().split(';')))
for node_id in ids:
node = graph.addNode({
'name': node_id
})
nodes.append(node)
else:
fields = [s.strip() for s in line.split(';')]
edges = map(float, filter(lambda s: len(s) > 0, fields[1:]))
source = nodes[line_no-1]
for col_no, edge in enumerate(edges):
if edge > 0:
target = nodes[col_no-1]
graph.addEdge(source, target)
line_no += 1
return graph
def setUp(self):
self.graph = tlp.newGraph()
self.boolean_prop = self.graph.getBooleanProperty(
boolean_prop_param_value)
self.color_prop = self.graph.getColorProperty(color_prop_param_value)
self.double_prop = self.graph.getDoubleProperty(
double_prop_param_value)
self.int_prop = self.graph.getIntegerProperty(int_prop_param_value)
self.layout_prop = self.graph.getLayoutProperty(
layout_prop_param_value)
self.size_prop = self.graph.getSizeProperty(size_prop_param_value)
self.string_prop = self.graph.getStringProperty(
string_prop_param_value)
self.boolean_vec_prop = self.graph.getBooleanVectorProperty(
boolean_vec_prop_param_default_value)
self.color_vec_prop = self.graph.getColorVectorProperty(
color_vec_prop_param_default_value)
self.double_vec_prop = self.graph.getDoubleVectorProperty(
double_vec_prop_param_default_value)
self.int_vec_prop = self.graph.getIntegerVectorProperty(
int_vec_prop_param_default_value)
self.coord_vec_prop = self.graph.getCoordVectorProperty(
coord_vec_prop_param_default_value)
self.size_vec_prop = self.graph.getSizeVectorProperty(
size_vec_prop_param_default_value)
self.string_vec_prop = self.graph.getStringVectorProperty(
string_vec_prop_param_default_value)
def bipartite_transformation(self) :
map_in_nodes={} ## vertices in self.graph -> corresponding duplicated vertices
map_out_nodes={} ## vertices in self.graph -> corresponding duplicated vertices
map_oends={}; ## arcs in bipartite graph -> edge in self.graph
edges=[];
for e in self.graph.getEdges() :
edges.append(e);
random.shuffle(edges); # shuffling arcs
bipart_g = tlp.newGraph();
## duplicate vertices
for e in edges :
n1,n2 = self.graph.ends(e);
if n1 not in map_out_nodes.keys() :
n_out = bipart_g.addNode();
map_out_nodes[n1]=n_out;
if n2 not in map_in_nodes.keys() :
n_in = bipart_g.addNode();
map_in_nodes[n2]=n_in;
a=bipart_g.addEdge(map_out_nodes[n1],map_in_nodes[n2])
map_oends[a]=e;
## connected the new nodes to source and sink nodes
s= bipart_g.addNode();
for n in map_out_nodes.values() :
bipart_g.addEdge(s,n);
t= bipart_g.addNode();
for n in map_in_nodes.values() :
bipart_g.addEdge(n,t);
return [bipart_g,map_oends,s,t]
def mspl_full(filter_spl=host.scripts.utils.filter_function_simple,
filter_pattern=host.scripts.utils.filter_function_simple,
label_spl=label_generator_simple,
label_pattern=core_data.pattern_to_atom):
graph = tlp.newGraph()
spl_nodes = {}
pattern_nodes = {}
for spl in hyportage_db.mspl.itervalues():
if filter_spl(spl):
node = graph.addNode()
spl_nodes[spl] = node
graph['viewLabel'][node] = label_spl(spl)
for pattern in hyportage_db.flat_pattern_repository.iterkeys():
if filter_pattern(pattern):
node = graph.addNode()
pattern_nodes[pattern] = node
graph['viewLabel'][node] = label_pattern(pattern)
spls = set(spl_nodes.keys())
patterns = set(pattern_nodes.keys())
for spl, node in spl_nodes.iteritems():
for pattern in spl.dependencies.iterkeys():
if pattern in patterns:
graph.addEdge(node, pattern_nodes[pattern])
for pattern, node in pattern_nodes.iteritems():
for spl in hyportage_db.flat_pattern_repository[pattern].matched_spls(
hyportage_db.mspl, hyportage_db.spl_groups):
if spl in spls:
graph.addEdge(node, spl_nodes[spl])
return graph, spl_nodes, pattern_nodes
def tree(graph, root):
res = tlp.newGraph()
equiv = {}
for n in graph.getNodes():
graph['visited'][n] = False
new_node = res.addNode()
equiv[root] = new_node
graph['visited'][root] = True
path = [new_node]
branches = [graph.getOutNodes(root)]
while branches:
if branches[-1].hasNext():
succ = branches[-1].next()
if not graph['visited'][succ]:
new_node = res.addNode()
equiv[succ] = new_node
res.addEdge(path[-1], new_node)
graph['visited'][succ] = True
path.append(new_node)
branches.append(graph.getOutNodes(succ))
else:
path.pop()
branches.pop()
return res, equiv
def bubble_layout_nx(G,
xmin=-750,
xmax=750,
ymin=-750,
ymax=750,
verbose=False):
"""Bubble-tree Layout using the Tulip library.
The input tree must be a graph. The layout is scaled so that it is
fit exactly within a bounding box.
Grivet, S., Auber, D., Domenger, J. P., & Melancon,
G. (2006). Bubble tree drawing algorithm. In Computer Vision and
Graphics (pp. 633-641). Springer Netherlands.
Parameters
----------
G : networkx.Graph
Tree
xmin : float, optional
Minimum x-coordinate of the bounding box
xmax : float, optional
Maximum x-coordinate of the bounding box
ymin : float, optional
Minimum y-coordinate of the bounding box
ymax : float, optional
Maximum y-coordinate of the bounding box
Returns
-------
dict
Dictionary mapping nodes to 2D coordinates. pos[node_name] -> (x,y)
"""
from tulip import tlp
# from tulip import *
# from tulipgui import *
graph = tlp.newGraph()
nodes = graph.addNodes(len(G.nodes()))
nodes_idx = make_index(G.nodes())
for x, y in G.edges():
graph.addEdge(nodes[nodes_idx[x]], nodes[nodes_idx[y]])
# Apply the 'Bubble Tree' graph layout plugin from Tulip
graph.applyLayoutAlgorithm('Bubble Tree')
viewLayout = graph.getLayoutProperty("viewLayout")
pos = {
g: (viewLayout[i].x(), viewLayout[i].y())
for i, g in zip(nodes, G.nodes())
}
pos = transform_pos(pos, xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax)
return pos
def import_sbml(input_model, sbml_file):
logging.info('parsing ChEBI')
chebi = parse_simple(get_chebi())
logging.info('reading generalized model from %s' % sbml_file)
r_id2g_id, s_id2gr_id, ub_sps = get_quotient_maps(chebi, sbml_file)
logging.info('fixing labels and compartments')
check_names(input_model)
check_compartments(input_model)
logging.info('annotating with GO')
go = parse_simple(get_go())
annotate_compartments(input_model, go)
c_id2level = comp2level(input_model, go)
c_id2info, c_id2outs = compute_c_id2info(c_id2level, input_model)
def get_r_comp(all_comp_ids):
if len(all_comp_ids) == 1:
return all_comp_ids.pop()
get_level = lambda c_id: c_id2level[c_id][0]
outer_most = min(all_comp_ids, key=get_level)
inner_most = max(all_comp_ids, key=get_level)
outer_level, inner_level = get_level(outer_most), get_level(inner_most)
if outer_level == inner_level or (outer_most
not in c_id2outs[inner_most]):
candidates = set(c_id2outs[inner_most]) & set(
c_id2outs[outer_most])
if candidates:
return max(candidates, key=get_level)
else:
return outer_most
if inner_level - outer_level > 1:
return max(c_id2outs[inner_most], key=get_level)
return outer_most
logging.info('initialising the graph')
graph = tlp.newGraph()
graph.setName(input_model.getId())
create_props(graph)
logging.info('adding species nodes')
id2n = species2nodes(graph, input_model, ub_sps)
logging.info('adding reaction nodes')
reactions2nodes(get_r_comp, graph, id2n, input_model)
# for n in (n for n in graph.getNodes() if TYPE_SPECIES == graph[TYPE][n] and graph.deg(n) > 5 \
# and not graph[ID][n] in s_id2gr_id):
# graph[UBIQUITOUS][n] = True
logging.info('duplicating nodes')
duplicate_nodes(graph)
logging.info('marking species/reaction groups')
mark_ancestors(graph, r_id2g_id, s_id2gr_id, c_id2info)
return graph, c_id2info, c_id2outs, chebi, ub_sps
def setUp(self):
self.graph = tlp.newGraph()
self.nodes = []
self.edges = []
for i in range(NB_NODES):
self.nodes.append(self.graph.addNode())
for i in range(NB_NODES - 1):
if i != NB_NODES - 2:
self.edges.append(self.graph.addEdge(self.nodes[i], self.nodes[i+1]))
else:
self.edges.append(self.graph.addEdge(self.nodes[i], self.nodes[0]))
self.edges.append(self.graph.addEdge(self.nodes[i], self.nodes[-1]))
def Execute(ith, root_path, graphname, layoutname):
#Inserting nodes and edges.
nnode, nedge, data = Load_graph(root_path + graphname)
graph = tlp.newGraph()
nodes = graph.addNodes(nnode)
data2 = [(nodes[n[0]], nodes[n[1]]) for n in data]
graph.addEdges(data2)
#Initializing the graph.
viewLayout = graph.getLayoutProperty("viewLayout")
LayoutName = 'Random layout'
LayoutParams = tlp.getDefaultPluginParameters(LayoutName, graph)
graph.applyLayoutAlgorithm(LayoutName, viewLayout, LayoutParams)
print("Graph Initalized!")
#Applying layout.
LayoutName = layoutname
LayoutParams = tlp.getDefaultPluginParameters(LayoutName, graph)
print('Nodes number:', len(nodes))
LayoutParams['number of pivots'] = int(len(nodes)**0.5)
# LayoutParams['number of pivots'] = 250
time_start = time.time()
print("Start applying layout: ", LayoutName, " Current time is ")
print(time.asctime(time.localtime(time_start)))
graph.applyLayoutAlgorithm(LayoutName, viewLayout, LayoutParams)
print("Layout Finished!")
time_end = time.time()
time_cost = time_end - time_start
print("Total time cost: ", time_cost)
#Output to the files.
outpath = "outputs/"
mylist = [(nnode, 2)]
coords = [viewLayout.getNodeValue(n) for n in nodes]
counter = 0
for c in coords:
row = (counter, c[0], c[1])
mylist.append(row)
counter = counter + 1
out_to_txt(mylist,
outfilename=outpath + os.path.splitext(graphname)[0] + "/" +
LayoutName + "_" + str(ith) + "_vec2D.txt")
return time_cost
def run(self):
# get parameters
self.k = self.dataSet["k"]
self.create_sg = self.dataSet["Create subgraphs?"]
self.create_prop = self.dataSet["Create property?"]
## compute max cliques
ds = tlp.DataSet()
ds["Create subgraphs?"] = False
ds["Create property?"] = True
[suc, errmsg] = self.graph.applyAlgorithm("Cliques Enumeration", ds)
if not suc:
return False
## build clique graph
cG = tlp.newGraph()
prop_memb = self.graph.getIntegerVectorProperty("clique_memb")
[count, label] = self.buildCliqueGraph(cG, prop_memb)
## Perform percolation
mapLabClust = self.percolation(cG, count, label)
## Save results
if self.create_prop:
final_clust = self.graph.getIntegerVectorProperty(
"clust_percolation_k=" + str(self.k))
for n in self.graph.getNodes():
final_clust.resizeNodeValue(n, 0)
set_clust = set()
for lab in prop_memb[n]:
set_clust.add(mapLabClust[lab])
for sc in set_clust:
final_clust.pushBackNodeEltValue(n, sc)
if self.create_sg:
mapLabNodes = {}
for n in self.graph.getNodes():
for lab in prop_memb[n]:
if mapLabClust[lab] not in mapLabNodes.keys():
mapLabNodes[mapLabClust[lab]] = []
mapLabNodes[mapLabClust[lab]].append(n)
for lab, cc in mapLabNodes.items():
sgg = self.graph.inducedSubGraph(cc)
sgg.setName("Cluster_" + str(lab))
## Delete temp variables
self.graph.delLocalProperty("clique_memb")
return True
def runLayout(graphID, algorithm):
with open('test_data/%s_links.json' % graphID) as f:
linksJson = json.loads(f.read())
g = tlp.newGraph()
nameToNode = {}
nodeToName = {}
for name in linksJson.keys():
node = g.addNode()
nameToNode[name] = node
nodeToName[node] = name
for source, targets in linksJson.items():
for target in targets:
g.addEdge(nameToNode[source], nameToNode[target])
layout = g.getLayoutProperty('viewLayout')
params = tlp.getDefaultPluginParameters(algorithm, g)
successful, errorMsg = g.applyLayoutAlgorithm(algorithm, layout, params)
if not successful:
raise Exception(errorMsg)
# params = tlp.getDefaultPluginParameters('Fast Overlap Removal', g)
# params['x border'] = 5
# params['y border'] = 5
# successful, errorMsg = g.applyLayoutAlgorithm('Fast Overlap Removal', layout, params)
# if not successful:
# raise Exception(errorMsg)
nameToNodeInfo = {}
for name, node in nameToNode.items():
x, y, z = layout[node]
nameToNodeInfo[name] = {
'x': x,
'y': y,
'name': name,
}
calcSizes(nameToNodeInfo, nodeToName, g)
normalize(nameToNodeInfo)
reduceGaps(nameToNodeInfo)
normalize(nameToNodeInfo)
# roundify(nameToNodeInfo)
# normalize(nameToNodeInfo)
return nameToNodeInfo
def setUp(self):
self.graph = tlp.newGraph()
self.nodes = []
self.edges = []
for i in range(NB_NODES):
self.nodes.append(self.graph.addNode())
for i in range(NB_NODES - 1):
if i != NB_NODES - 2:
self.edges.append(
self.graph.addEdge(self.nodes[i], self.nodes[i + 1]))
else:
self.edges.append(
self.graph.addEdge(self.nodes[i], self.nodes[0]))
self.edges.append(self.graph.addEdge(self.nodes[i],
self.nodes[-1]))
def setUp(self): self.graph = tlp.newGraph() self.boolean_prop = self.graph.getBooleanProperty(boolean_prop_param_value) self.color_prop = self.graph.getColorProperty(color_prop_param_value) self.double_prop = self.graph.getDoubleProperty(double_prop_param_value) self.int_prop = self.graph.getIntegerProperty(int_prop_param_value) self.layout_prop = self.graph.getLayoutProperty(layout_prop_param_value) self.size_prop = self.graph.getSizeProperty(size_prop_param_value) self.string_prop = self.graph.getStringProperty(string_prop_param_value) self.boolean_vec_prop = self.graph.getBooleanVectorProperty(boolean_vec_prop_param_default_value) self.color_vec_prop = self.graph.getColorVectorProperty(color_vec_prop_param_default_value) self.double_vec_prop = self.graph.getDoubleVectorProperty(double_vec_prop_param_default_value) self.int_vec_prop = self.graph.getIntegerVectorProperty(int_vec_prop_param_default_value) self.coord_vec_prop = self.graph.getCoordVectorProperty(coord_vec_prop_param_default_value) self.size_vec_prop = self.graph.getSizeVectorProperty(size_vec_prop_param_default_value) self.string_vec_prop = self.graph.getStringVectorProperty(string_vec_prop_param_default_value)
def makeGraph(m,airportl,carL,dicoAir,airportperlay):
graph=tlp.newGraph()
latitude=graph.getDoubleProperty("latitude")
longitude=graph.getDoubleProperty("longitude")
name = graph.getStringProperty("nameCity")
code = graph.getStringProperty("code")
couche = graph.getStringVectorProperty("compagnie")
color = graph.getColorProperty("viewColor")
k=len(carL)
colList=[(randint(0,255),randint(0,255),randint(0,255)) for i in range(k)]
for n in range(len(airportl)):
graph.addNode()
no=graph.nodes()[n]
code[no]=airportl[n]
listeAttributs=dicoAir[airportl[n]]
name[no]=listeAttributs[0]
latitude[no]=float(listeAttributs[1])
longitude[no]=float(listeAttributs[2])
n=0
for lay in m.giveLayers().giveLayers():
car=lay.giveLayerLabel()[0]
sub=graph.addSubGraph(car)
nliste=airportperlay[car]
for node1 in nliste :
no=graph.nodes()[airportl.index(node1)]
sub.addNode(no)
#print(car,len(sub.nodes()))
for e in m.giveLinks().giveListOfLinks():
n1=graph.nodes()[airportl.index(e.giveNodes()[0].giveNode())]
n2=graph.nodes()[airportl.index(e.giveNodes()[1].giveNode())]
graph.addEdge(n1,n2)
ed=graph.edges()[n]
n=n+1
couche[ed]=e.giveLabel()[2]
color[ed]=colList[carL.index(e.giveLabel()[2][0])]
sub=graph.subGraphs()[carL.index(e.giveLabel()[2][0])]
car=e.giveLabel()[2][0]
codenode=e.giveNodes()[0].giveNode()
n1=sub.nodes()[airportperlay[car].index(codenode)]
n2=sub.nodes()[airportperlay[e.giveLabel()[2][0]].index(e.giveNodes()[1].giveNode())]
sub.addEdge(ed)
tlp.saveGraph(graph,"output/grapheplanes.tlp")
return(graph)
def bipartite_transformation(self, G, forced_arc=tlp.edge()):
map_in_nodes = {
} ## vertices in self.graph -> corresponding duplicated vertices
map_out_nodes = {
} ## vertices in self.graph -> corresponding duplicated vertices
map_oends = {}
## arcs in bipartite graph -> edge in G
edges = []
for e in G.getEdges():
if e != forced_arc:
edges.append(e)
# forced_arc is assumed to be part of the assignment
random.shuffle(edges)
# shuffling arcs
bipart_g = tlp.newGraph()
## duplicate vertices
for e in edges:
n1, n2 = G.ends(e)
if n1 not in map_out_nodes.keys():
n_out = bipart_g.addNode()
map_out_nodes[n1] = n_out
if n2 not in map_in_nodes.keys():
n_in = bipart_g.addNode()
map_in_nodes[n2] = n_in
a = bipart_g.addEdge(map_out_nodes[n1], map_in_nodes[n2])
map_oends[a] = e
## connected the new nodes to source and sink nodes
s = bipart_g.addNode()
for n in map_out_nodes.values():
bipart_g.addEdge(s, n)
t = bipart_g.addNode()
for n in map_in_nodes.values():
bipart_g.addEdge(n, t)
return [bipart_g, map_oends, s, t]
def generate_graph():
#creation d'un nouveau graphe vide
graph = tlp.newGraph()
comic = graph.getStringProperty("comic")
hero = graph.getStringProperty("hero")
type_ = graph.getStringProperty("type")
viewBorderColor = graph.getColorProperty("viewBorderColor")
viewBorderWidth = graph.getDoubleProperty("viewBorderWidth")
viewColor = graph.getColorProperty("viewColor")
viewFont = graph.getStringProperty("viewFont")
viewFontSize = graph.getIntegerProperty("viewFontSize")
viewIcon = graph.getStringProperty("viewIcon")
viewLabel = graph.getStringProperty("viewLabel")
viewLabelBorderColor = graph.getColorProperty("viewLabelBorderColor")
viewLabelBorderWidth = graph.getDoubleProperty("viewLabelBorderWidth")
viewLabelColor = graph.getColorProperty("viewLabelColor")
viewLabelPosition = graph.getIntegerProperty("viewLabelPosition")
viewLayout = graph.getLayoutProperty("viewLayout")
viewShape = graph.getIntegerProperty("viewShape")
viewSize = graph.getSizeProperty("viewSize")
type_node = graph.getIntegerProperty("Type")
#Fonction qui crée les noeuds en leur affectant le nom du comic ou du personnage, le type de noeud (noeud du personnage central, d'un comic, d'un personnage autre) et le graphe auquel ça s'applique
def create_node(nom, type, graph):
n1 = graph.addNode()
viewLabel[n1] = nom
type_node[n1] = type
return n1
name = request.args.get("name")
char_hash = {}
comic_hash = {}
#on récupère les données sur le personnage central depuis le site Marvel
r = requests.get(
'https://gateway.marvel.com:443/v1/public/characters?name=' + name +
'&limit=100&apikey=4dff50d15e38e094affa81c7191ac0bd',
headers={'referer': 'localhost'})
id_hero = -1
print("Code de retour=>", r.status_code)
if r.status_code == 200:
data_reply = r.json()
print("Nombre de personnages trouve : ",
len(data_reply["data"]["results"]))
for character in data_reply["data"]["results"]:
print("id personnage=>", character['id'], " xx nom personnage=>",
character['name'])
id_hero = character['id']
else:
print("Erreur de telechargement")
#On récupère les données sur les comics dans lesquels apparaît notre personnage central ainsi que les autres personnages qui apparaissent dans ces comics.
r2 = requests.get(
'https://gateway.marvel.com:443/v1/public/characters/' + str(id_hero) +
'/comics?limit=100&apikey=4dff50d15e38e094affa81c7191ac0bd',
headers={'referer': 'localhost'})
if r2.status_code == 200:
data_reply2 = r2.json()
#Boucle qui crée le noeud central et rempli le dictionnaire json
for character in data_reply["data"]["results"]:
n1 = create_node(character["name"], 0, graph)
char_hash[character["name"]] = n1
#Boucle qui crée les noeuds des comics et rempli le dictionnaire json
for comic in data_reply2["data"]["results"]:
node = create_node(comic["title"], 1, graph)
comic_hash[comic["title"]] = node
#Création des arrêtes
for target in graph.getNodes():
if type_node[target] == 0:
source = target
graph.addEdge(source, target)
#Boucle qui crée les noeuds des autres personnages et rempli le dictionnaire json
for comic in data_reply2["data"]["results"]:
for name in comic["characters"]["items"]:
if name["name"] in char_hash.keys():
n = char_hash[name["name"]]
else:
n = create_node(name["name"], 2, graph)
char_hash[name["name"]] = n
destination = comic_hash[comic["title"]]
graph.addEdge(n, destination)
#Création du json
gjson = {'nodes': [], 'links': []}
for n in graph.getNodes():
gjson['nodes'].append({'id': viewLabel[n], 'group': type_node[n]})
for e in graph.getEdges():
gjson['links'].append({
'source': viewLabel[graph.source(e)],
'target': viewLabel[graph.target(e)],
'value': 1
})
return jsonify(gjson)
import csv
from tulip import tlp
from tulipgui import tlpgui
graph = tlp.newGraph()
viewLabel = graph.getStringProperty("viewLabel")
def set_node(field, cache_key=None):
if cache_key is None:
cache_key = field
for value in project[field].split(';'):
if value not in cache[cache_key].keys():
node = graph.addNode()
cache[cache_key][value] = node
with open('dataset/cordis-fp7projects.csv', 'r', newline='',
encoding='utf-8') as f:
projects = csv.DictReader(f, delimiter='\t', quotechar='"')
print(projects.fieldnames)
cache = {name: {} for name in projects.fieldnames}
cache['project'] = {}
small_projects = list(projects)[:10]
for project in small_projects:
p = graph.addNode()
cache['project'][project['id']] = p
def main(graph):
Acronyme = graph.getStringProperty("Acronyme")
Annee_de_financement = graph.getIntegerProperty("Année de financement")
Code_du_programme = graph.getStringProperty("Code du programme")
Code_du_projet = graph.getStringProperty("Code du projet")
Code_du_type_de_partenaire = graph.getStringVectorProperty("Code du type de partenaire")
Coordinateur_du_projet = graph.getStringProperty("Coordinateur du projet")
Date_de_debut = graph.getIntegerProperty("Date de début")
Duree_en_mois = graph.getIntegerProperty("Durée en mois")
Identifiant_de_partenaire = graph.getStringVectorProperty("Identifiant de partenaire")
Libelle_de_partenaire = graph.getStringVectorProperty("Libellé de partenaire")
Lien_Programme = graph.getStringProperty("Lien Programme")
Lien_Projet = graph.getStringProperty("Lien Projet")
Montant = graph.getDoubleProperty("Montant")
Perspectives = graph.getStringProperty("Perspectives")
Programme = graph.getStringProperty("Programme")
Publications_et_brevets = graph.getStringProperty("Publications et brevets")
Resultats = graph.getStringProperty("Résultats")
Resume = graph.getStringProperty("Résumé")
Resume_de_la_soumission = graph.getStringProperty("Résumé de la soumission")
Sigle_de_partenaire = graph.getStringVectorProperty("Sigle de partenaire")
Titre = graph.getStringProperty("Titre")
Type_didentifiant = graph.getStringVectorProperty("Type d'identifiant")
Type_de_partenaire = graph.getStringVectorProperty("Type de partenaire")
viewBorderColor = graph.getColorProperty("viewBorderColor")
viewBorderWidth = graph.getDoubleProperty("viewBorderWidth")
viewColor = graph.getColorProperty("viewColor")
viewFont = graph.getStringProperty("viewFont")
viewFontSize = graph.getIntegerProperty("viewFontSize")
viewIcon = graph.getStringProperty("viewIcon")
viewLabel = graph.getStringProperty("viewLabel")
viewLabelBorderColor = graph.getColorProperty("viewLabelBorderColor")
viewLabelBorderWidth = graph.getDoubleProperty("viewLabelBorderWidth")
viewLabelColor = graph.getColorProperty("viewLabelColor")
viewLabelPosition = graph.getIntegerProperty("viewLabelPosition")
viewLayout = graph.getLayoutProperty("viewLayout")
viewMetric = graph.getDoubleProperty("viewMetric")
viewRotation = graph.getDoubleProperty("viewRotation")
viewSelection = graph.getBooleanProperty("viewSelection")
viewShape = graph.getIntegerProperty("viewShape")
viewSize = graph.getSizeProperty("viewSize")
viewSrcAnchorShape = graph.getIntegerProperty("viewSrcAnchorShape")
viewSrcAnchorSize = graph.getSizeProperty("viewSrcAnchorSize")
viewTexture = graph.getStringProperty("viewTexture")
viewTgtAnchorShape = graph.getIntegerProperty("viewTgtAnchorShape")
viewTgtAnchorSize = graph.getSizeProperty("viewTgtAnchorSize")
start_time = time.time()
partenaire=tlp.newGraph()
list=[]
print ('Cr�ation des noeuds:')
for n in graph.getNodes():
libPart=Libelle_de_partenaire[n]
for i in range (0,len(libPart)):
if "Universit�" in libPart[i]:
if libPart[i] not in list : #si on rencontre ce partenaire pour la première fois
list.append(libPart[i])
node=partenaire.addNode()
x=random.randrange(1,1025,1)
y=random.randrange(1, 1025, 1)
projet=[Acronyme[n]]
communs=[]
for j in range (0,len(libPart)):
if libPart[j]!=libPart[i] and libPart[j] not in communs and "Universit�" in libPart[j]:
communs.append(libPart[j])
dict={"Libell� de partenaire": libPart[i], "Projet" : projet ,"Partenaires communs": communs ,"viewColor":(200,150,80,230) ,"viewLayout":tlp.Coord(x,y,0)}
partenaire.setNodePropertiesValues(node,dict)
else : #ce partenaire a déjà un noeud, on le cherche alors parmi tous les noeuds du nouveau graphe, et on ajoute dans ses paramètres le projet n et les partenaires communs
for o in partenaire.getNodes():
if libPart[i] == partenaire.getStringProperty("Libell� de partenaire")[o] and Acronyme[n] not in partenaire.getStringVectorProperty("Projet")[o] :
communs=[]
for j in range (0,len(libPart)):
if libPart[j]!=libPart[i] and libPart[j] not in communs and libPart[j] not in partenaire.getStringVectorProperty("Partenaires communs")[o] and "Universit�" in libPart[j]:
communs.append(libPart[j])
dict={"Libell� de partenaire": partenaire.getStringProperty("Libell� de partenaire")[o] , "Projet" : partenaire.getStringVectorProperty("Projet")[o]+[Acronyme[n]] , "Partenaires communs": partenaire.getStringVectorProperty("Partenaires communs")[o]+communs, "viewColor":(200,150,80,230)}
partenaire.setNodePropertiesValues(o,dict)
print ("Cr�ation des ar�tes")
node1=0
for p in partenaire.getNodes():
node2=0
for q in partenaire.getNodes():
for i in partenaire.getStringVectorProperty("Projet")[p] :
if i in partenaire.getStringVectorProperty("Projet")[q] and partenaire.getStringProperty("Libell� de partenaire")[q] in partenaire.getStringVectorProperty("Partenaires communs")[p] and p!=q and node2>=node1 : #node1 et node2 pour éviter que les arêtes soient en double
e=partenaire.addEdge(p,q)
dict={"Projet":[i],"Partenaires" :[partenaire.getStringProperty("Libell� de partenaire")[p],partenaire.getStringProperty("Libell� de partenaire")[q]]}
partenaire.setEdgePropertiesValues(e,dict)
node2+=1
node1+=1
print ("Louvain")
params = tlp.getDefaultPluginParameters('Louvain', partenaire)
partenaire.applyDoubleAlgorithm('Louvain', params)
tlp.saveGraph(partenaire,"univlouv.tlp")
interval = time.time() - start_time
print ('Total time in seconds:', interval)
def getLayout(self, chooseList=[]):
# return {'nodes': self.nodes, 'links': self.links}
# print(choo)
if (chooseList == []):
chooseList = np.arange(len(self.nodes))
graph = tlp.newGraph()
nodeListOld = {}
for i, item in enumerate(chooseList):
nodeListOld[item] = i
linkList = []
nodeList = {}
duList = {}
tot = 0
for item in self.links:
if (nodeListOld.__contains__(item['source'])
or nodeListOld.__contains__(item['target'])):
linkList.append(item)
if (nodeList.__contains__(item['source']) == False):
nodeList[item['source']] = tot
duList[item['source']] = 0
tot += 1
if (nodeList.__contains__(item['target']) == False):
nodeList[item['target']] = tot
duList[item['target']] = 0
tot += 1
duList[item['source']] |= 1
duList[item['target']] |= 2
nodes = graph.addNodes(len(nodeList))
edgeData = []
for item in linkList:
edgeData.append((nodes[nodeList[item['source']]],
nodes[nodeList[item['target']]]))
graph.addEdges(edgeData)
viewLayout = graph.getLayoutProperty("viewLayout")
LayoutName = 'Random layout'
LayoutParams = tlp.getDefaultPluginParameters(LayoutName, graph)
graph.applyLayoutAlgorithm(LayoutName, viewLayout, LayoutParams)
print("Graph Initalized!")
LayoutName = 'FM^3 (OGDF)'
LayoutParams = tlp.getDefaultPluginParameters(LayoutName, graph)
print('Nodes number:', len(nodes))
graph.applyLayoutAlgorithm(LayoutName, viewLayout, LayoutParams)
coords = [viewLayout.getNodeValue(n) for n in nodes]
nodeResult = []
for item in nodeList:
tmpNode = self.nodes[item].copy()
tmpNode.update({
'x': coords[nodeList[item]][0],
'y': coords[nodeList[item]][1],
'du': duList[item]
})
nodeResult.append(tmpNode)
print("Layout Finished!")
linksResult = []
for i in range(len(linkList)):
tmpNode = linkList[i].copy()
tmpNode.update({
'source': {
'x': coords[nodeList[tmpNode['source']]][0],
'y': coords[nodeList[tmpNode['source']]][1]
},
'target': {
'x': coords[nodeList[tmpNode['target']]][0],
'y': coords[nodeList[tmpNode['target']]][1]
}
})
linksResult.append(tmpNode)
return {'nodes': nodeResult, 'links': linksResult}
