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 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 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 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)