def partitionnement(graph, nbPartitionMax=1, currentPartition=0):
if currentPartition == nbPartitionMax:
return None
poids = graph.getDoubleProperty("Weight")
min_lvl = poids.getEdgeDoubleMin()
max_lvl = poids.getEdgeDoubleMax()
for edge in graph.getEdges():
poids[edge] = (poids[edge] - min_lvl) / (max_lvl - min_lvl)
params = tlp.getDefaultPluginParameters('MCL Clustering')
params['weights'] = graph.getDoubleProperty("Weight")
resultMetric = graph.getDoubleProperty('resultMetric' +
str(currentPartition + 1))
success = graph.applyDoubleAlgorithm('MCL Clustering', resultMetric,
params)
params = tlp.getDefaultPluginParameters('Equal Value', graph)
params['Property'] = resultMetric
success = graph.applyAlgorithm('Equal Value', params)
for sousGraph in graph.getSubGraphs():
# poids = sousGraph.getDoubleProperty("Weight")
# min_lvl = poids.getEdgeDoubleMin()
# max_lvl = poids.getEdgeDoubleMax()
# for edge in sousGraph.getEdges():
# poids[edge]=(poids[edge]-min_lvl)/(max_lvl-min_lvl)
partitionnement(sousGraph, nbPartitionMax, currentPartition + 1)
def prettify_codes_hierarchy():
'''
(None) => None
layout on the codes hierarchy
'''
# apply size mapping
params = tlp.getDefaultPluginParameters("Size Mapping", graph)
params['min size'] = 2
params['max size'] = 40
params['property'] = annotations_count
graph.applySizeAlgorithm('Size Mapping', params)
# color mapping: nodes
colors = [tlp.Color.Gray, tlp.Color.Red]
colorScale = tlp.ColorScale(colors)
params = tlp.getDefaultPluginParameters("Color Mapping", graph)
params['input property'] = annotations_count
params['type'] = 'logarithmic'
params['target'] = 'nodes'
params['color scale'] = colorScale
graph.applyColorAlgorithm('Color Mapping', params)
# layout
params = tlp.getDefaultPluginParameters('Balloon (OGDF)', graph)
graph.applyLayoutAlgorithm('Balloon (OGDF)', params)
def show_graph(self):
params_post = tlp.getDefaultPluginParameters('Bubble Tree')
self.graph_post.applyLayoutAlgorithm('Bubble Tree', params_post)
nodeLinkView = tlpgui.createView("Node Link Diagram view",
self.graph_post, {}, True)
nodeLinkView.centerView()
params_user = tlp.getDefaultPluginParameters('Circular')
self.graph_user.applyLayoutAlgorithm('Circular', params_user)
nodeLinkView = tlpgui.createView("Node Link Diagram view",
self.graph_user, {}, True)
nodeLinkView.centerView()
def visu_algoFM(gr):
"""
Input : The graph
Function : Apply the FM3 algorithm to the graph
Output : NONE
"""
params = tlp.getDefaultPluginParameters("FM^3 (OGDF)", gr)
params["Unit Edge Length"] = gr["Distance"]
gr.applyLayoutAlgorithm("FM^3 (OGDF)", params)
params = tlp.getDefaultPluginParameters("Perfect aspect ratio", gr)
gr.applyLayoutAlgorithm('Perfect aspect ratio', params)
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 layout_force(qo, margin=1):
root = qo.getRoot()
ds = tlp.getDefaultPluginParameters(FM3, qo)
ds["Unit edge length"] = 2 * SPECIES_SIZE + margin
qo.applyLayoutAlgorithm(FM3, root[VIEW_LAYOUT], ds)
remove_overlaps(qo, margin)
def applyRoutingAlgorithms(G,mu,alpha,decay,epsilon) :
flow_value=G.getDoubleProperty("flow");
is_road=G.getBooleanProperty("is_road");
length=G.getDoubleProperty("length");
ds= tlp.getDefaultPluginParameters("Shortest-Path Routing", G)
ds["is road"]=is_road;
ds["flow value"]=flow_value;
ds["length"]=length;
ds["mu"]=mu;
ds["alpha"]=alpha;
ds["decay"]=decay;
ds["epsilon"]=epsilon;
ds2=ds;
res_sp=G.getDoubleProperty("speed_sp");
start_time = time.time()
G.applyDoubleAlgorithm("Shortest-Path Routing",res_sp,ds);
time_sp = (time.time() - start_time);
n_steps_sp = ds["final nb steps"]
res_bio=G.getDoubleProperty("speed_bio");
start_time = time.time()
[finish_bio,error_msg]=G.applyDoubleAlgorithm("Physarum Solver",res_bio,ds2);
if not finish_bio :
print error_msg
time_bio = (time.time() - start_time);
n_steps_bio = ds2["final nb steps"]
return [res_sp,n_steps_sp,time_sp,res_bio,n_steps_bio,time_bio];
def preprocessing(gr):
"""
Affect a pre-treatment to a graph (Size of nodes, color edges, add nodes name, etc...).
@type gr: tlp.Graph
@param gr: current graph
"""
# Load properties
viewLabel = gr.getStringProperty("viewLabel")
LabelPosition = gr.getIntegerProperty("viewLabelPosition")
layout = gr.getLayoutProperty("viewLayout")
viewSize = gr.getSizeProperty("viewSize")
viewColor = gr.getColorProperty("viewColor")
viewShape = gr.getIntegerProperty("viewShape")
Locus = gr.getStringProperty("Locus")
# Define colors
green = tlp.Color(0, 255, 0)
red = tlp.Color(255, 0, 0)
size = (60.0, 60.0, 60.0)
for n in graph.getNodes():
viewLabel[n] = Locus[n]
viewSize[n] = size
viewShape[n] = 14 #circle
LabelPosition[n] = tlp.LabelPosition.Center
for e in gr.getEdges():
properties = gr.getEdgePropertiesValues(e)
if (properties["Positive"] == True):
viewColor[e] = green
else:
viewColor[e] = red
# Apply drawing algorithm
paramalgo = tlp.getDefaultPluginParameters("FM^3 (OGDF)")
paramalgo["Node size"] = 'viewSize'
gr.applyLayoutAlgorithm("FM^3 (OGDF)", layout, paramalgo)
def run(self):
scaling = 1000
if self.dataSet:
scaling = self.dataSet["layout scaling"]
params = tlp.getDefaultPluginParameters('H3', self.graph)
success, errmsg = self.graph.applyLayoutAlgorithm("H3", params)
if not success:
if self.pluginProgress:
self.pluginProgress.setError(errmsg)
return False
self.graph['viewBorderWidth'].setAllNodeValue(0)
self.graph['viewShape'].setAllNodeValue(tlp.NodeShape.Sphere)
self.graph['viewTgtAnchorShape'].setAllEdgeValue(tlp.EdgeExtremityShape.Cone)
for n in self.graph.getNodes():
w = self.graph['viewSize'][n][0]
h = self.graph['viewSize'][n][1]
s = min(w, h)
self.graph['viewSize'][n] = tlp.Size(s)
if tulipGuiOk:
for v in tlpgui.getViewsOfGraph(self.graph):
if isinstance(v, tlpgui.NodeLinkDiagramComponent):
rp = v.getRenderingParameters()
rp.setEdge3D(True)
rp.setViewArrow(True)
rp.setLabelsAreBillboarded(True)
v.setRenderingParameters(rp)
return True
def run(self):
scaling = 1000
if self.dataSet:
scaling = self.dataSet["layout scaling"]
params = tlp.getDefaultPluginParameters('H3', self.graph)
success, errmsg = self.graph.applyLayoutAlgorithm("H3", params)
if not success:
if self.pluginProgress:
self.pluginProgress.setError(errmsg)
return False
self.graph['viewBorderWidth'].setAllNodeValue(0)
self.graph['viewShape'].setAllNodeValue(tlp.NodeShape.Sphere)
self.graph['viewTgtAnchorShape'].setAllEdgeValue(
tlp.EdgeExtremityShape.Cone)
for n in self.graph.getNodes():
w = self.graph['viewSize'][n][0]
h = self.graph['viewSize'][n][1]
s = min(w, h)
self.graph['viewSize'][n] = tlp.Size(s)
if tulipGuiOk:
for v in tlpgui.getViewsOfGraph(self.graph):
if isinstance(v, tlpgui.NodeLinkDiagramComponent):
rp = v.getRenderingParameters()
rp.setEdge3D(True)
rp.setViewArrow(True)
rp.setLabelsAreBillboarded(True)
v.setRenderingParameters(rp)
return True
def colorNodes(g, property, color):
heatMap = tlp.ColorScale([tlp.Color.Red, tlp.Color.Black, tlp.Color.Green])
params = tlp.getDefaultPluginParameters('Color Mapping', g)
params['input property'] = property
params['target'] = 'nodes'
params['color scale'] = heatMap
g.applyColorAlgorithm('Color Mapping', params)
def main(graph):
src = graph.getIntegerProperty("src")
trg = graph.getIntegerProperty("trg")
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")
for n in graph.getNodes():
print n
viewColor = 'black'
params = tlp.getDefaultPluginParameters('Tree Leaf', graph)
params['layout'] = 'center'
resultLayout = graph.getLayoutProperty('perfectAspectRartio')
success = graph.applyLayoutAlgorithm('Tree Leaf', params)
def main(graph):
g = graph.addCloneSubGraph("clone")
id_ = g['id']
ds = tlp.getDefaultPluginParameters("Betweenness Centrality", g)
ds['target'] = "nodes"
with open('betweness.csv', 'w') as f:
writer = csv.writer(f)
writer.writerow(
['nb_sommets', 'mesure', 'taille_composante', 'lg moyenne'])
for i in range(100):
#on veut le calcul uniquement sur les sommets
betweenness = tlp.DoubleProperty(g)
g.applyDoubleAlgorithm("Betweenness Centrality", betweenness, ds)
#Sommet qui a la plus grande valeur
n = betweenness.getNodesEqualTo(betweenness.getNodeMax(g),
g).next()
g.delNode(n)
comp = tlp.ConnectedTest.computeConnectedComponents(g)
maxl = 0
for n in comp:
if (len(n) > maxl):
maxl = len(n)
writer.writerow([
i, 'betweeness centrality', maxl / g.numberOfNodes(),
tlp.averagePathLength(g)
])
def layout_force(qo, margin=1):
root = qo.getRoot()
ds = tlp.getDefaultPluginParameters(FM3, qo)
ds["Unit edge length"] = 2 * SPECIES_SIZE + margin
qo.applyLayoutAlgorithm(FM3, root[VIEW_LAYOUT], ds)
remove_overlaps(qo, margin)
def initLabels(graph, locus, label, labelBorderWidth, labelPosition):
params=tlp.getDefaultPluginParameters('To labels',graph)
params['input'] = locus
graph.applyStringAlgorithm('To labels',label ,params)
labelBorderWidth.setAllNodeValue(0)
center = 0
labelPosition.setAllNodeValue(center)
def getDataWordCloud():
global hero
global nb_heroes
global best_heroes
list_heroes = []
edge_value = 0
word_cloud = []
heroes_graph = tlp.loadGraph('heroes_final.tlpb')
node = heroes_graph['viewLabel'].getNodesEqualTo(hero).next()
heroes_graph['viewSelection'].setAllNodeValue(False)
heroes_graph['viewSelection'][node] = True
params = tlp.getDefaultPluginParameters('Reachable SubGraph', heroes_graph)
params['distance'] = 1
params['edge direction'] = 'all edges'
heroes_graph.applyBooleanAlgorithm('Reachable SubGraph', params)
heroes_graph.addSubGraph(heroes_graph['viewSelection'],
name="SubGraph_hero")
SubGraph_hero = heroes_graph.getSubGraph("SubGraph_hero")
# compute node degree
metricprop = SubGraph_hero.getDoubleProperty("viewMetric")
SubGraph_hero.applyDoubleAlgorithm("Degree", metricprop)
# get 10 characters with the highest Degree (most published)
picon = SubGraph_hero.getStringProperty("viewIcon")
plabel = SubGraph_hero.getStringProperty("viewLabel")
i = 0
# iterate in descending order (max to min)
for n in metricprop.getSortedNodes(None, False):
if picon[n] == "md-human" and plabel[n] in best_heroes:
if (plabel[node] == hero and plabel[n] != hero):
for edge in tlp.Graph.allEdges(SubGraph_hero, node):
if tlp.Graph.source(SubGraph_hero,
edge) == n or tlp.Graph.target(
SubGraph_hero, edge) == n:
edge_value = tlp.Graph.getEdgePropertiesValues(
SubGraph_hero, edge)['value']
break
word_cloud.append((plabel[node], plabel[n], edge_value))
# produce a csv return it
csvdata = io.StringIO()
writer = csv.writer(csvdata, delimiter=",")
if (plabel[node] == hero and plabel[n] == hero):
i -= 1
i += 1
if (i == nb_heroes):
break
writer.writerow(("group", "name", "val"))
for n in word_cloud:
writer.writerow(n)
output = make_response(csvdata.getvalue())
output.headers[
"Content-Disposition"] = "attachment; filename=data_word_cloud.csv"
output.headers["Content-type"] = "text/csv"
return output
def Algorithms(graph, viewLayout, viewMCLMetric, viewMetric):
""" Permet l'implémentation de l'algorithme de dessin et de cluster """
fm3pParams = tlp.getDefaultPluginParameters("FM^3 (OGDF)", graph)
graph.applyLayoutAlgorithm("FM^3 (OGDF)", viewLayout, fm3pParams)
#params = tlp.getDefaultPluginParameters('Fast Overlap Removal', graph)
#graph.applyLayoutAlgorithm('Fast Overlap Removal', params)
params = tlp.getDefaultPluginParameters("Edge bundling", graph)
graph.applyAlgorithm("Edge bundling", params)
MCLparams = tlp.getDefaultPluginParameters("MCL Clustering", graph)
MCLparams['weights'] = viewMetric
graph.applyDoubleAlgorithm("MCL Clustering", viewMCLMetric, MCLparams)
EVparams = tlp.getDefaultPluginParameters("Equal Value", graph)
EVparams['Property'] = viewMCLMetric
graph.applyAlgorithm("Equal Value", EVparams)
def color_graph(gr, param, color):
params = tlp.getDefaultPluginParameters("Color Mapping", gr)
params["input property"] = param
print params #Voir a quoi ressemble la liste des couleurs
params["minimum value"] = 0
params["maximum value"] = 15
#params["color scale"]=
gr.applyColorAlgorithm("Color Mapping", color, params)
return # stub
def layout_circle(qo, margin=1):
root = qo.getRoot()
ds = tlp.getDefaultPluginParameters(CIRCULAR, qo)
if qo.numberOfNodes() > 1:
dist = get_distance(qo) + margin
ds["minDistCircle"] = dist
ds["minDistLevel"] = dist
ds["minDistCC"] = 1
ds["minDistSibling"] = dist
qo.applyLayoutAlgorithm(CIRCULAR, root[VIEW_LAYOUT], ds)
def import_from_query():
"""Use the query drawer plugin to draw the built query"""
params = tlp.getDefaultPluginParameters("QueryDrawer")
params['Query'] = query.get()
params['URI'] = self.dataSet['URI']
params["User name"] = self.dataSet["User name"]
params["Password"] = self.dataSet["Password"]
params["Directory path"] = self.dataSet["Directory path"]
tlp.copyToGraph(self.graph, tlp.importGraph("QueryDrawer", params))
root.destroy()
def layout_circle(qo, margin=1):
root = qo.getRoot()
ds = tlp.getDefaultPluginParameters(CIRCULAR, qo)
if qo.numberOfNodes() > 1:
dist = get_distance(qo) + margin
ds["minDistCircle"] = dist
ds["minDistLevel"] = dist
ds["minDistCC"] = 1
ds["minDistSibling"] = dist
qo.applyLayoutAlgorithm(CIRCULAR, root[VIEW_LAYOUT], ds)
def colorSmallMultiples(smallMultiplesTree):
for sg in smallMultiplesTree.getSubGraphs():
sgMetric = sg.getLocalDoubleProperty("viewMetric")
params = tlp.getDefaultPluginParameters('Color Mapping', sg)
params['input property'] = sgMetric
colorScaleManager = tlpgui.ColorScalesManager
colorScale = colorScaleManager.getColorScale("BiologicalHeatMap")
params['color scale'] = colorScale
sg.applyColorAlgorithm('Color Mapping', params)
def preTraitementVisualisation(graph):
"""
Pré-traitement & première visualisation du graph
"""
# Partie 1
viewLabel = graph.getStringProperty("viewLabel")
Locus = graph.getStringProperty("Locus")
viewSize = graph.getSizeProperty("viewSize")
viewFontSize = graph.getIntegerProperty("viewFontSize")
viewColor = graph.getColorProperty("viewColor")
viewTgtAnchorShape = graph.getIntegerProperty("viewTgtAnchorShape")
viewTgtAnchorSize = graph.getSizeProperty("viewTgtAnchorSize")
node_size = tlp.Size(100000, 30000, 1)
for n in graph.getNodes():
#Ajoute des labels issu de Locus aux neouds du graph
viewLabel[n] = Locus[n]
viewFontSize[n] = 1
#Affection d'une taille non null à chaque sommet afin de pouvoir visualiser correctement les étiquettes
viewSize[n] = node_size
# Affectation des couleurs des arretes et la forme des extremités selon le type de régulation (positive ou negative)
Negative = graph.getBooleanProperty("Negative")
blue = tlp.Color(58, 95, 205)
square = tlp.EdgeExtremityShape.Square
Positive = graph.getBooleanProperty("Positive")
green = tlp.Color(69, 139, 0)
arrow = tlp.EdgeExtremityShape.Arrow
for e in graph.getEdges():
if Negative[e] is True:
#Regulation negatif
viewColor[e] = blue
viewTgtAnchorShape[e] = square
elif Positive[e] is True:
#regulation poistive
viewColor[e] = green
viewTgtAnchorShape[e] = arrow
viewTgtAnchorSize[e] = node_size
#Affectation des positions aux sommets du graphe par l'application un model de force "FM^3 (OGDF)"
viewLayout = graph.getLayoutProperty("viewLayout")
fm3pParams = tlp.getDefaultPluginParameters("FM^3 (OGDF)", graph)
fm3pParams["Unit edge length"] = 400
graph.applyLayoutAlgorithm("FM^3 (OGDF)", viewLayout, fm3pParams)
def apply_radial_algorithm(gr, viewLayout):
"""
Apply the "Tree Radial" algorithme on gr
@param gr: Tulip graph
@param viewLayout: layout property
"""
params = tlp.getDefaultPluginParameters("Tree Radial", gr)
params["layer spacing"] = 64
params["node spacing"] = 18
gr.applyLayoutAlgorithm("Tree Radial", viewLayout, params)
def layout_hierarchically(qo, margin=1):
root = qo.getRoot()
ds = tlp.getDefaultPluginParameters(HIERARCHICAL_GRAPH, qo)
if qo.numberOfNodes() > 1:
# looks like there is a bug in Tulip and it uses the 'layer spacing' value
# instead of the 'node spacing' one and visa versa
d = SPECIES_SIZE + margin #get_distance(qo)
ds["layer spacing"] = d
ds["node spacing"] = d
ds["layer distance"] = d
ds["node distance"] = d
qo.applyLayoutAlgorithm(HIERARCHICAL_GRAPH, root[VIEW_LAYOUT], ds)
def layout_hierarchically(qo, margin=1):
root = qo.getRoot()
ds = tlp.getDefaultPluginParameters(HIERARCHICAL_GRAPH, qo)
if qo.numberOfNodes() > 1:
# looks like there is a bug in Tulip and it uses the 'layer spacing' value
# instead of the 'node spacing' one and visa versa
d = SPECIES_SIZE + margin #get_distance(qo)
ds["layer spacing"] = d
ds["node spacing"] = d
ds["layer distance"] = d
ds["node distance"] = d
qo.applyLayoutAlgorithm(HIERARCHICAL_GRAPH, root[VIEW_LAYOUT], ds)
def color_graph(gr, param, color):
"""
"""
params = tlp.getDefaultPluginParameters("Color Mapping", gr)
colorScale = tlp.ColorScale([])
params["input property"] = param
colors = color_gradient(20)
# colors = [tlp.Color.Red, tlp.Color.Black, tlp.Color.Green] # can be use intead of previous line
colorScale.setColorScale(colors)
params["color scale"] = colorScale
gr.applyColorAlgorithm("Color Mapping", color, params)
def actorsHeatmap(k=40):
k = 40 if k < 10 or k > 80 else k
g = tlp.loadGraph(FRNetworkURL)
name = g.getStringProperty("name")
viewMetric = g.getDoubleProperty("viewMetric")
value = g.getIntegerProperty("value")
degree = g.getDoubleProperty("degree")
params = tlp.getDefaultPluginParameters("Degree", g)
params['metric'] = value
g.applyDoubleAlgorithm("Degree", degree, params)
topActors = []
actors = []
i = 0
for n in viewMetric.getSortedNodes(ascendingOrder=False):
if (i == k):
break
else:
i = i + 1
topActors.append(n)
actor = {}
actor['name'] = name[n]
actors.append(actor)
data = []
for i in range(k):
sum = 0
for j in range(k):
row = {}
row['actor1'] = name[topActors[i]]
row['actor2'] = name[topActors[j]]
row['collaborations'] = 0
for e in g.getEdges(topActors[i], topActors[j]):
row['collaborations'] += value[e]
sum += value[e]
for e in g.getEdges(topActors[j], topActors[i]):
row['collaborations'] += value[e]
sum += value[e]
data.append(row)
data[i * k + i]['collaborations'] = sum # diagonal values
actors[i]['count'] = sum
return render_template(
"acteurs_heatmap.html",
title=
"Heatmap des acteurs et actrices francophones les plus prolifiques",
actors=actors,
data=data)
def clusteringMCL(graph, weight_prop, result_name):
"""
Effectue un partionnement race au plugin MCL clustering
"""
params = tlp.getDefaultPluginParameters('MCL Clustering', graph)
params['weights'] = weight_prop
resultMetric = graph.getDoubleProperty(result_name)
print("MCL clustering start")
success = graph.applyDoubleAlgorithm('MCL Clustering', resultMetric,
params)
print("MCL clustering is over", success)
return resultMetric
def partitionnement(graph, nbPartitionMax=1, currentPartition=0):
'''
Crée un partitionnement multi-niveaux. Le nombre de niveaux est égal à nbPartitionMax.
Le numéro du cluster pour un gène est indiqué dans la propriété 'cluster'. Le nombre suivant le nom de la propriété indique le niveau de profondeur du partitionnement.
Par exemple, 'cluster1' correspond au premier niveau, 'cluster2' au deuxième niveau, etc...
'''
if currentPartition == nbPartitionMax:
return None
poids = graph.getDoubleProperty("Weight")
min_lvl = poids.getEdgeDoubleMin()
max_lvl = poids.getEdgeDoubleMax()
for edge in graph.getEdges():
poids[edge] = (poids[edge] - min_lvl) / (max_lvl - min_lvl)
params = tlp.getDefaultPluginParameters('MCL Clustering')
params['weights'] = graph.getDoubleProperty("Weight")
cluster = graph.getDoubleProperty('cluster' + str(currentPartition + 1))
success = graph.applyDoubleAlgorithm('MCL Clustering', cluster, params)
params = tlp.getDefaultPluginParameters('Equal Value', graph)
params['Property'] = cluster
success = graph.applyAlgorithm('Equal Value', params)
for sousGraph in graph.getSubGraphs():
partitionnement(sousGraph, nbPartitionMax, currentPartition + 1)
def coloring_nodes(graph):
"""This is an example algorithm that colors nodes depending on their degree"""
blue = tlp.Color(0, 0, 255)
green = tlp.Color(0, 255, 0)
viewColor = graph.getColorProperty("viewColor")
viewMetric = graph.getDoubleProperty("viewMetric")
success, about = graph.applyDoubleAlgorithm(
'Betweenness Centrality',
tlp.getDefaultPluginParameters('Betweenness Centrality', graph))
if success:
for n in graph.getNodes():
viewColor[n] = blue if viewMetric[n] > 10 else green
else:
print(about)
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 main(graph):
id_ = graph['id']
viewBorderColor = graph['viewBorderColor']
viewBorderWidth = graph['viewBorderWidth']
viewColor = graph['viewColor']
viewFont = graph['viewFont']
viewFontSize = graph['viewFontSize']
viewIcon = graph['viewIcon']
viewLabel = graph['viewLabel']
viewLabelBorderColor = graph['viewLabelBorderColor']
viewLabelBorderWidth = graph['viewLabelBorderWidth']
viewLabelColor = graph['viewLabelColor']
viewLabelPosition = graph['viewLabelPosition']
viewLayout = graph['viewLayout']
viewMetric = graph['viewMetric']
viewRotation = graph['viewRotation']
viewSelection = graph['viewSelection']
viewShape = graph['viewShape']
viewSize = graph['viewSize']
viewSrcAnchorShape = graph['viewSrcAnchorShape']
viewSrcAnchorSize = graph['viewSrcAnchorSize']
viewTexture = graph['viewTexture']
viewTgtAnchorShape = graph['viewTgtAnchorShape']
viewTgtAnchorSize = graph['viewTgtAnchorSize']
picon = graph.getStringProperty("viewIcon")
plabel = graph.getStringProperty("viewLabel")
graph['viewSelection'].setAllNodeValue(False)
# name = 'Marvel Super Heroes (1990) #2'
# node = graph['viewLabel'].getNodesEqualTo(name).next()
# graph['viewSelection'][node]=True
for n in graph.getNodes():
if picon[n] == 'md-book-open':
voisins = list(tlp.Graph.getInOutNodes(graph, n))
counter = 1
for x in voisins:
for y in voisins[counter:]:
tlp.Graph.addEdge(graph, x, y, propertiesValues=None)
counter += 1
params = tlp.getDefaultPluginParameters('Reachable SubGraph',
graph)
params['distance'] = 1
params['edge direction'] = 'all edges'
subgraph = graph.applyBooleanAlgorithm('Reachable SubGraph',
params)
tlp.Graph.delNode(graph, n)
def test_plugin_out_parameters(self):
plugin_params = tlp.getDefaultPluginParameters(plugin_name, self.graph)
plugin_ret = self.graph.applyAlgorithm(plugin_name, plugin_params)
self.assertTrue(plugin_ret[0])
self.assertIn(out_boolean_param_name, plugin_params)
self.assertEqual(plugin_params[out_boolean_param_name], out_boolean_param_value)
self.assertIn(out_int_param_name, plugin_params)
self.assertEqual(plugin_params[out_int_param_name], out_int_param_value)
self.assertIn(out_float_param_name, plugin_params)
self.assertEqual(plugin_params[out_float_param_name], out_float_param_value)
self.assertIn(out_string_param_name, plugin_params)
self.assertEqual(plugin_params[out_string_param_name], out_string_param_value)
def set_layout(graph, root):
t, equiv = tree(graph, root)
#inv_equiv = {v: k for k, v in equiv.iteritems()}
# 1. clean the graph
t_nodes = t.nodes()
to_delete = {n for n in graph.getNodes() if n not in equiv}
for n in to_delete:
graph.delNode(n)
# 2. compute the layout
layout = "Tree Radial"
params = tlp.getDefaultPluginParameters(layout, t)
t.applyLayoutAlgorithm(layout, params)
for n in graph.getNodes():
graph['viewLayout'][n] = t['viewLayout'][n]
# 3. compute the size
set_node_size(graph, scale=4)
def run(self):
# retrieve parameter values
metric = self.dataSet['metric']
aspectRatio = self.dataSet['aspect ratio']
treeMapType = self.dataSet['treemap type']
borderColor = self.dataSet['border color']
layout = self.dataSet['layout']
sizes = self.dataSet['sizes']
shapes = self.dataSet['shapes']
colors = self.dataSet['colors']
borderColors = self.dataSet['border colors']
borderWidths = self.dataSet['border widths']
# call the 'Squarified Tree Map' layout algorithm
params = tlp.getDefaultPluginParameters('Squarified Tree Map', self.graph)
params['Node Size'] = sizes
params['Node Shape'] = shapes
params['metric'] = metric
params['Aspect Ratio'] = aspectRatio
params['Treemap Type'] = treeMapType
self.graph.applyLayoutAlgorithm('Squarified Tree Map', layout, params)
# set edge colors and border colors to be fully transparent
colors.setAllEdgeValue(tlp.Color(0, 0, 0, 0))
borderColors.setAllEdgeValue(tlp.Color(0, 0, 0, 0))
# set new border color for nodes
borderColors.setAllNodeValue(borderColor)
# ensure node borders are visible
borderWidths.setAllNodeValue(1.0)
# set the square shape to all leaf nodes
for n in self.graph.getNodes():
if self.graph.outdeg(n) == 0:
shapes[n] = tlp.NodeShape.Square
return True
def test_plugin_default_parameters(self):
plugin_default_params = tlp.getDefaultPluginParameters(plugin_name, self.graph)
self.assertIn(boolean_param_name, plugin_default_params)
self.assertEqual(type(plugin_default_params[boolean_param_name]), bool)
self.assertEqual(plugin_default_params[boolean_param_name], boolean_param_default_value)
self.assertIn(color_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[color_param_name], tlp.Color))
self.assertEqual(repr(plugin_default_params[color_param_name]), color_param_default_value)
self.assertIn(color_scale_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[color_scale_param_name], tlp.ColorScale))
self.assertEqual(plugin_default_params[color_scale_param_name], tlp.ColorScale(color_scale_default_value_dict))
self.assertIn(int_param_name, plugin_default_params)
if sys.version_info >= (3,):
self.assertEqual(type(plugin_default_params[int_param_name]), int)
else:
self.assertEqual(type(plugin_default_params[int_param_name]), long)
self.assertEqual(plugin_default_params[int_param_name], int_param_default_value)
self.assertIn(float_param_name, plugin_default_params)
self.assertEqual(type(plugin_default_params[float_param_name]), float)
self.assertEqual(plugin_default_params[float_param_name], float_param_default_value)
self.assertIn(string_param_name, plugin_default_params)
self.assertEqual(type(plugin_default_params[string_param_name]), str)
self.assertEqual(plugin_default_params[string_param_name], string_param_default_value)
self.assertIn(string_collection_param_name, plugin_default_params)
self.assertEqual(type(plugin_default_params[string_collection_param_name]), str)
self.assertEqual(plugin_default_params[string_collection_param_name], string_collection_param_default_value.split(';')[0])
self.assertIn(boolean_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[boolean_prop_param_name], tlp.BooleanProperty))
self.assertEqual(plugin_default_params[boolean_prop_param_name].getName(), boolean_prop_param_default_value)
self.assertIn(color_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[color_prop_param_name], tlp.ColorProperty))
self.assertEqual(plugin_default_params[color_prop_param_name].getName(), color_prop_param_default_value)
self.assertIn(double_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[double_prop_param_name], tlp.DoubleProperty))
self.assertEqual(plugin_default_params[double_prop_param_name].getName(), double_prop_param_default_value)
self.assertIn(int_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[int_prop_param_name], tlp.IntegerProperty))
self.assertEqual(plugin_default_params[int_prop_param_name].getName(), int_prop_param_default_value)
self.assertIn(layout_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[layout_prop_param_name], tlp.LayoutProperty))
self.assertEqual(plugin_default_params[layout_prop_param_name].getName(), layout_prop_param_default_value)
self.assertIn(size_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[size_prop_param_name], tlp.SizeProperty))
self.assertEqual(plugin_default_params[size_prop_param_name].getName(), size_prop_param_default_value)
self.assertIn(string_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[string_prop_param_name], tlp.StringProperty))
self.assertEqual(plugin_default_params[string_prop_param_name].getName(), string_prop_param_default_value)
self.assertIn(boolean_vec_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[boolean_vec_prop_param_name], tlp.BooleanVectorProperty))
self.assertEqual(plugin_default_params[boolean_vec_prop_param_name].getName(), boolean_vec_prop_param_default_value)
self.assertIn(color_vec_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[color_vec_prop_param_name], tlp.ColorVectorProperty))
self.assertEqual(plugin_default_params[color_vec_prop_param_name].getName(), color_vec_prop_param_default_value)
self.assertIn(double_vec_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[double_vec_prop_param_name], tlp.DoubleVectorProperty))
self.assertEqual(plugin_default_params[double_vec_prop_param_name].getName(), double_vec_prop_param_default_value)
self.assertIn(int_vec_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[int_vec_prop_param_name], tlp.IntegerVectorProperty))
self.assertEqual(plugin_default_params[int_vec_prop_param_name].getName(), int_vec_prop_param_default_value)
self.assertIn(coord_vec_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[coord_vec_prop_param_name], tlp.CoordVectorProperty))
self.assertEqual(plugin_default_params[coord_vec_prop_param_name].getName(), coord_vec_prop_param_default_value)
self.assertIn(size_vec_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[size_vec_prop_param_name], tlp.SizeVectorProperty))
self.assertEqual(plugin_default_params[size_vec_prop_param_name].getName(), size_vec_prop_param_default_value)
self.assertIn(string_vec_prop_param_name, plugin_default_params)
self.assertTrue(isinstance(plugin_default_params[string_vec_prop_param_name], tlp.StringVectorProperty))
self.assertEqual(plugin_default_params[string_vec_prop_param_name].getName(), string_vec_prop_param_default_value)
def test_plugin_in_parameters(self):
plugin_params = tlp.getDefaultPluginParameters(plugin_name, self.graph)
plugin_params[boolean_param_name] = boolean_param_value
plugin_params[int_param_name] = int_param_value
plugin_params[float_param_name] = float_param_value
plugin_params[string_param_name] = string_param_value
plugin_params[string_collection_param_name] = string_collection_param_value
plugin_params[color_scale_param_name] = color_scale_param_value
plugin_params[color_param_name] = color_param_value
plugin_params[boolean_prop_param_name] = self.boolean_prop
plugin_params[color_prop_param_name] = self.color_prop
plugin_params[double_prop_param_name] = self.double_prop
plugin_params[int_prop_param_name] = self.int_prop
plugin_params[layout_prop_param_name] = self.layout_prop
plugin_params[size_prop_param_name] = self.size_prop
plugin_params[string_prop_param_name] = self.string_prop
plugin_params[boolean_vec_prop_param_name] = self.boolean_vec_prop
plugin_params[color_vec_prop_param_name] = self.color_vec_prop
plugin_params[double_vec_prop_param_name] = self.double_vec_prop
plugin_params[int_vec_prop_param_name] = self.int_vec_prop
plugin_params[coord_vec_prop_param_name] = self.coord_vec_prop
plugin_params[size_vec_prop_param_name] = self.size_vec_prop
plugin_params[string_vec_prop_param_name] = self.string_vec_prop
plugin_ret = self.graph.applyAlgorithm(plugin_name, plugin_params)
self.assertTrue(plugin_ret[0])
self.assertEqual(parameters_value[boolean_param_name], boolean_param_value)
self.assertEqual(parameters_value[int_param_name], int_param_value)
self.assertEqual(parameters_value[float_param_name], float_param_value)
self.assertEqual(parameters_value[string_param_name], string_param_value)
self.assertEqual(parameters_value[string_param_name], string_param_value)
self.assertEqual(parameters_value[string_collection_param_name], string_collection_param_value)
self.assertEqual(parameters_value[color_param_name], color_param_value)
self.assertEqual(parameters_value[color_scale_param_name], color_scale_param_value)
self.assertEqual(parameters_value[boolean_prop_param_name], self.boolean_prop)
self.assertEqual(parameters_value[color_prop_param_name], self.color_prop)
self.assertEqual(parameters_value[double_prop_param_name], self.double_prop)
self.assertEqual(parameters_value[int_prop_param_name], self.int_prop)
self.assertEqual(parameters_value[layout_prop_param_name], self.layout_prop)
self.assertEqual(parameters_value[size_prop_param_name], self.size_prop)
self.assertEqual(parameters_value[string_prop_param_name], self.string_prop)
self.assertEqual(parameters_value[boolean_vec_prop_param_name], self.boolean_vec_prop)
self.assertEqual(parameters_value[color_vec_prop_param_name], self.color_vec_prop)
self.assertEqual(parameters_value[double_vec_prop_param_name], self.double_vec_prop)
self.assertEqual(parameters_value[int_vec_prop_param_name], self.int_vec_prop)
self.assertEqual(parameters_value[coord_vec_prop_param_name], self.coord_vec_prop)
self.assertEqual(parameters_value[size_vec_prop_param_name], self.size_vec_prop)
self.assertEqual(parameters_value[string_vec_prop_param_name], self.string_vec_prop)
plugin_params[color_param_name] = color_param_tuple_value
del parameters_value[color_param_name]
plugin_params[color_scale_param_name] = color_scale_param_value_dict
del parameters_value[color_scale_param_name]
plugin_ret = self.graph.applyAlgorithm(plugin_name, plugin_params)
self.assertTrue(plugin_ret[0])
self.assertEqual(parameters_value[color_param_name], color_param_value)
self.assertEqual(parameters_value[color_scale_param_name], color_scale_param_value)
plugin_params[color_scale_param_name] = color_scale_param_value_list
del parameters_value[color_scale_param_name]
plugin_ret = self.graph.applyAlgorithm(plugin_name, plugin_params)
self.assertTrue(plugin_ret[0])
self.assertEqual(parameters_value[color_scale_param_name], color_scale_param_value)
plugin_params[string_collection_param_name] = 'toto'
with self.assertRaises(Exception) as cm:
plugin_ret = self.graph.applyAlgorithm(plugin_name, plugin_params)
self.assertContains(cm.exception.args[0], 'Possible values are : foo, bar')
def pack_cc(graph):
root = graph.getRoot()
ds = tlp.getDefaultPluginParameters(COMPONENT_PACKING, graph)
graph.applyLayoutAlgorithm(COMPONENT_PACKING, root[VIEW_LAYOUT], ds)
def remove_overlaps(graph, margin=1):
root = graph.getRoot()
ds = tlp.getDefaultPluginParameters(OVERLAP_REMOVAL, graph)
ds["x border"] = margin
ds["y border"] = margin
graph.applyLayoutAlgorithm(OVERLAP_REMOVAL, root[VIEW_LAYOUT], ds)
