def visu_node_edge(gr, size, color, viewBorderColor, viewBorderWidth): """ Input : The graph, the viewSize, the viewColor property, the viewBorderColor and the viewBorderWidth properties Function : Applies a style with the help of a dictionary "aspect" on the nodes and the edges regarding their properties Output : NONE """ interaction = gr["Interaction"] expression = gr["Expression"] aspect = { "node": { "up": [tlp.Color(0, 255, 0), tlp.Size(2, 2, 2)], "down": [tlp.Color(255, 0, 0), tlp.Size(2, 2, 2)], "stable": [tlp.Color(105, 105, 105), tlp.Size(1, 1, 1)], "intergenic": [tlp.Color(200, 200, 200), tlp.Size(1, 1, 1)], "nan": [tlp.Color(255, 255, 255), tlp.Size(1, 1, 1)] }, "edge": { "gain": [tlp.Color.Blue, 10], "loss": [tlp.Color.Yellow, 10], "stable": [tlp.Color.Gray, 0] } } for node in gr.getNodes(): color[node] = aspect["node"][expression[node]][0] size[node] = aspect["node"][expression[node]][1] for edge in gr.getEdges(): viewBorderColor[edge] = aspect["edge"][interaction[edge]][0] viewBorderWidth[edge] = aspect["edge"][interaction[edge]][1] color[edge] = aspect["edge"][interaction[edge]][0]
def Graphism(graph, viewShape, viewColor, viewLabel, Locus, viewBorderColor, viewBorderWidth, viewSize, Negative, Positive): """ Prétraitement colorant les arêtes et les noeuds """ for n in graph.getEdges(): viewShape[n] = tlp.EdgeShape.BezierCurve if (Negative[n] == False and Positive[n] == True): viewColor[n] = tlp.Color.Jade if (Negative[n] == True and Positive[n] == False): viewColor[n] = tlp.Color.Salmon if (Negative[n] == True and Positive[n] == True): viewColor[n] = tlp.Color.Lilac if (Negative[n] == False and Positive[n] == False): viewColor[n] = tlp.Color.Black for n in graph.getNodes(): viewLabel[n] = Locus[n] viewShape[n] = tlp.NodeShape.RoundedBox viewColor[n] = tlp.Color.BlueGreen viewBorderColor[n] = tlp.Color.Black viewBorderWidth[n] = 3 viewSize[n] = tlp.Size(1, 0.3, 1) if (n.id == 1307): viewLabel[n] = " LacZ " viewColor[n] = tlp.Color.Red viewSize[n] = tlp.Size(20, 8, 20)
def main(graph): #graph.applyAlgorithm("Incremental") pos = graph.getLayoutProperty("viewLayout") previous_pos = tlp.LayoutProperty(graph) color = graph.getColorProperty("viewColor") size = graph.getSizeProperty("viewSize") it = 0 steps = 100 for g in graph.getSubGraphs(): print(g) sg_pos = g.getLocalLayoutProperty("viewLayout") is_new_node = g.getLocalBooleanProperty("isNewNode") is_new_edge = g.getLocalBooleanProperty("isNewEdge") sg_color = g.getLocalColorProperty("viewColor") for n in graph.getNodes(): if not n in g.getNodes(): color[n] = tlp.Color(0, 0, 0, 0) pos[n] = sg_pos[g.getOneNode()] else: color[n] = sg_color[n] pos[n] = sg_pos[n] for e in graph.getEdges(): if not e in g.getEdges(): color[e] = tlp.Color(0, 0, 0, 0) else: color[e] = sg_color[e] if it > 0: for n in is_new_node.getNodesEqualTo(True): pos[n] = sg_pos[n] color[n].setA(0) size[n] = tlp.Size(6) for e in is_new_edge.getEdgesEqualTo(True): color[e].setA(0) for i in range(1, steps + 1): t = 1.0 * i / steps # "/" operator <=> integer division in python 2.7, hence the float constant for n in g.getNodes(): if is_new_node[n]: alpha = lerp(0, 255, t) c = color[n] color[n] = tlp.Color(c.getR(), c.getG(), c.getB(), int(alpha)) else: pos[n] = lerp(previous_pos[n], sg_pos[n], t) for e in g.getEdges(): if is_new_edge[e]: alpha = lerp(0, 255, t) c = color[e] color[e] = tlp.Color(c.getR(), c.getG(), c.getB(), int(alpha)) updateVisualization(True) for n in is_new_node.getNodesEqualTo(True): size[n] = tlp.Size(1) updateVisualization(True) #pauseScript() #time.sleep(0.1) previous_pos.copy(sg_pos) it += 1
def displayClusterToHeatmap(heatmap, nodes, all_tp, yi, maximum, minimum, stepx, stepy, display_gene_name=False): """ Fonction d'écriture du heatmap en lui même Pour chaque gene du groupe crée une ligne avec ces valeur d'expression """ viewSize = heatmap.getSizeProperty("viewSize") viewColor = heatmap.getColorProperty("viewColor") viewLayout = heatmap.getLayoutProperty("viewLayout") viewBorderColor = heatmap.getColorProperty("viewBorderColor") viewLabel = graph.getStringProperty("viewLabel") Locus = graph.getStringProperty("Locus") viewFontSize = graph.getIntegerProperty("viewFontSize") heatmap_color = tlp.ColorScale( [tlp.Color.Green, tlp.Color.Black, tlp.Color.Red]) for n in nodes: xi = 0 for tpi, tp in enumerate(all_tp): new_n = heatmap.addNode() viewSize[new_n] = tlp.Size(stepx, stepy, 1) viewLayout[new_n] = tlp.Coord(xi, yi, 0) pos = (tp[n] - minimum) / (maximum - minimum) viewColor[new_n] = heatmap_color.getColorAtPos(pos) viewBorderColor[new_n] = heatmap_color.getColorAtPos(pos) xi += stepx ## ne marche pas encore if display_gene_name: new_n = heatmap.addNode() viewSize[new_n] = tlp.Size(1, 1, 1) viewLayout[new_n] = tlp.Coord(xi, yi, 0) viewLabel[new_n] = Locus[n] viewFontSize[new_n] = stepy viewColor[new_n] = tlp.Color.White viewBorderColor[new_n] = tlp.Color.White yi += stepy
def visGraph(G) : flow=G.getDoubleProperty("flow"); color=G.getColorProperty("viewColor"); color.setAllNodeValue(tlp.Color(0,0,0,0)); size=G.getSizeProperty("viewSize"); for u in G.getNodes() : if flow[u]>0 : color[u]=tlp.Color(255,0,0,255); u_s = (flow[u]-flow.getNodeMin())/(flow.getNodeMax()-flow.getNodeMin())*1.+0.05; size[u]=tlp.Size(u_s,u_s,1.); else : size[u]=tlp.Size(0.001,0.001,1.);
def construireGrille(distance, gr): ''' Crée une grille où les gènes sont présents en ordonnée, et en abscisse les valeurs d'expression pour un gène. Les gènes sont ordonnés en fonction du partitionnement du graphe, quelque soit le niveau. ''' computeY(distance) positionY = distance.getDoubleProperty("PositionY") layout = gr.getLayoutProperty("viewLayout") tps = gr.getDoubleProperty("Tps") viewSize = gr.getSizeProperty("viewSize") decalageX = 100 decalageY = 1.5 Locus = distance.getStringProperty("Locus") locusToY = {} for node in distance.getNodes(): locusToY[Locus[node]] = positionY[node] Locus = gr.getStringProperty("Locus") count = {} for n in gr.getNodes(): currentLocus = Locus[n] viewSize[n] = tlp.Size(decalageX, decalageY, 1) x = tps[n] y = locusToY[Locus[n]] layout[n] = tlp.Coord(x * decalageX, y * decalageY, 0)
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 layout_components(graph, cycle_number_threshold=40, node_number_threshold=300, margin=5): root = graph.getRoot() comp_list = tlp.ConnectedTest.computeConnectedComponents(graph) followers_rev_or_gen = lambda n, gr: ( gr.opposite(e, n) for e in gr.getInOutEdges(n) if n == gr.source(e) or gr[REVERSIBLE][e] or gr.isMetaNode( n) and gr.isMetaNode(gr.opposite(e, n))) followers_rev = lambda n, gr: (gr.opposite(e, n) for e in gr.getInOutEdges(n) if n == gr.source(e) or gr[REVERSIBLE][e]) followers_irrev = lambda n, gr: gr.getOutNodes(n) followers_irrev_gen_only = lambda n, gr: (m for m in gr.getOutNodes(n) if gr.isMetaNode(m)) def process_cc(gr, ns, meta_ns, follower_method_iterator): try: follower_method = next(follower_method_iterator) except StopIteration: if len(ns) < node_number_threshold: mn = gr.createMetaNode(ns, False) cc_graph = root[VIEW_META_GRAPH][mn] layout_hierarchically(cc_graph) meta_ns.append(mn) return # iterate over strongly connected components for cc in tarjan_iter({n: list(follower_method(n, gr)) for n in ns}): if len(cc) > 3: if dfs(cc[0], gr, set(), None, cycle_number_threshold, follower_method) \ <= cycle_number_threshold: mn = gr.createMetaNode(cc, False) cc_graph = root[VIEW_META_GRAPH][mn] layout_circle(cc_graph, margin) meta_ns.append(mn) else: process_cc(gr, cc, meta_ns, follower_method_iterator) for ns in comp_list: gr = graph.inducedSubGraph(ns) meta_ns = [] process_cc( gr, (n for n in gr.getNodes() if gr[TYPE][n] != TYPE_COMPARTMENT), meta_ns, iter((followers_rev_or_gen, followers_rev, followers_irrev, followers_irrev_gen_only))) for mn in meta_ns: root[VIEW_SHAPE][mn] = COMPARTMENT_SHAPE w, h = get_mn_size(mn, root) root[VIEW_SIZE][mn] = tlp.Size(w, h) if gr.numberOfNodes() < node_number_threshold and \ not next((n for n in gr.getNodes() if root[TYPE][n] == TYPE_COMPARTMENT), False): layout_hierarchically(gr) else: layout_force(gr, margin) for mn in meta_ns: gr.openMetaNode(mn)
def apply_node_coordinates(graph, n2xy): root = graph.getRoot() for n in graph.getNodes(): n_id = root[ID][n] if n_id in n2xy: xywh = n2xy[n_id] if isinstance(xywh, dict): for r_id, ((x, y), (w, h)) in xywh.items(): if root[CLONE_ID][n].find(r_id) != -1: root[VIEW_LAYOUT][n] = tlp.Coord(x, y) root[VIEW_SIZE][n] = tlp.Size(w, h) break else: (x, y), (w, h) = xywh root[VIEW_LAYOUT][n] = tlp.Coord(x, y) root[VIEW_SIZE][n] = tlp.Size(w, h) elif graph.isMetaNode(n): x, y = 0, 0 w, h = 0, 0 count = 0 for m in root[VIEW_META_GRAPH][n].getNodes(): if root[ID][m] in n2xy: xywh_ = n2xy[root[ID][m]] if isinstance(xywh_, dict): for r_id, ((x_, y_), (w_, h_)) in xywh_.items(): if root[CLONE_ID][m].find(r_id) != -1: x += x_ y += y_ w += w_ h += h_ count += 1 break else: (x_, y_), (w_, h_) = xywh_ count += 1 x += x_ y += y_ w += w_ h += h_ if count: root[VIEW_LAYOUT][n] = tlp.Coord(x / count, y / count) root[VIEW_SIZE][n] = tlp.Size(w, h) root[VIEW_LAYOUT].setAllEdgeValue([])
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 Heatmap(heatmap, graph, TP, viewColor, viewSize, viewMCLMetric, viewMean, viewStd): """ Permet la création de la heatmap """ maxCluster = 0 count = 1.0 for n in graph.getNodes(): if viewMCLMetric[n] > maxCluster: maxCluster = int(viewMCLMetric[n]) for j in range(maxCluster): for n in graph.getNodes(): if viewMCLMetric[n] == j: for i in range(len(TP)): tpValue = (TP[i][n] - viewMean[n]) / viewStd[n] if (tpValue >= 0): heatmap.addNode({ "viewLayout": tlp.Coord(i, count / 20.0, 0), "viewColor": tlp.Color(0, int(255 / 2 * tpValue), 0), "viewSize": tlp.Size(1, 0.05, 1), "viewMCLMetric": j }) else: heatmap.addNode({ "viewLayout": tlp.Coord(i, count / 20.0, 0), "viewColor": tlp.Color(-int(255 / 2 * tpValue), 0, 0), "viewSize": tlp.Size(1, 0.05, 1), "viewMCLMetric": j }) count += 1
def pretraitement(graph, Locus, Negative, Positive, viewBorderColor, viewLabel, viewLayout, viewSize): size = 1000 for n in graph.getNodes(): viewSize[n] = tlp.Size(10000, 3000, 10) viewLabel[n] = Locus[n] for n in graph.getEdges(): if Negative[n] == True: if Positive[n] == True: viewBorderColor[n] = tlp.Color.Black else: viewBorderColor[n] = tlp.Color(0, 0, 225) elif Positive[n] == True: viewBorderColor[n] = tlp.Color(0, 200, 0)
def pretraitement(graph, Locus, Negative, Positive, viewBorderColor, viewLabel, viewLayout, viewSize): ''' Change la taille et la couleur des éléments du graphe afin qu'il soit plus lisible ''' size = 1000 for n in graph.getNodes(): viewSize[n] = tlp.Size(10000,3000,10) viewLabel[n] = Locus[n] for n in graph.getEdges(): if Negative[n] == True: if Positive[n] == True: viewBorderColor[n] = tlp.Color.Black else: viewBorderColor[n] = tlp.Color(0,0,225) elif Positive[n] == True: viewBorderColor[n] = tlp.Color(0,200,0)
def defineGraph(graph, Locus, viewLabel, viewColor, viewSize, Positive, Negative): for n in graph.getNodes(): viewLabel[n] = str(Locus[n]) #viewShape[n] = viewSize[n] = tlp.Size(1, 2, 3) for n in graph.getEdges(): if ((Positive[n] == True) and (Negative[n] == False)): viewColor[n] = tlp.Color.Blush elif ((Positive[n] == False) and (Negative[n] == True)): viewColor[n] = tlp.Color.Sapphire elif ((Positive[n] == True) and (Negative[n] == True)): viewColor[n] = tlp.Color.Orange elif ((Positive[n] == False) and (Negative[n] == False)): viewColor[n] = tlp.Color.Green
def createTreeNode(heatmap, dx, yi, yinext, label): """ Gere la creation d'un neouds du cluster """ viewLayout = graph.getLayoutProperty("viewLayout") viewLabel = graph.getStringProperty("viewLabel") viewColor = heatmap.getColorProperty("viewColor") viewSize = heatmap.getSizeProperty("viewSize") ynode = yi + (yinext - yi) / 2.0 xnode = -dx node = heatmap.addNode() viewLayout[node] = tlp.Coord(xnode, ynode, 0) viewLabel[node] = label viewColor[node] = tlp.Color.White viewSize[node] = tlp.Size(1, 1, 0) return node
def construireGrille(distance, gr): increment = getIncrement(distance, distance) positionY = distance.getDoubleProperty("PositionY") layout = gr.getLayoutProperty("viewLayout") tps = gr.getDoubleProperty("Tps") viewSize = gr.getSizeProperty("viewSize") decalageX = 100 decalageY = 1.5 Locus = distance.getStringProperty("Locus") locusToY = {} for node in distance.getNodes(): locusToY[Locus[node]] = positionY[node] Locus = gr.getStringProperty("Locus") count = {} for n in gr.getNodes(): currentLocus = Locus[n] viewSize[n] = tlp.Size(decalageX, decalageY, 1) x = tps[n] y = locusToY[Locus[n]] layout[n] = tlp.Coord(x * decalageX, y * decalageY, 0)
def preProcess(graph,locus,label,size,color,regPositive,regNegative,layout,labelColor,labelBorderColor): """ Function for preprocessing the root graph before applying main algorithms. This function permits to get the first vizualisation of the root graph. It will apply labels corresponding to the locus at each nodes. A size to each nodes in order to be able to see the labels. A color to each edges of the root graph in function of their regulation type. And finally, a layout algorithm, here the "Random Layout", to store a position for each nodes. Args: rootGraph (tlp.Graph) : the graph to preprocess and visualize locus (tlp.StringProperty) : a property linked to the loci of a gene, or a node label (tlp.StringProperty) : a property linked to the "viewLayout" of the root graph size (tlp.DoubleProperty) : a property linked to the "viewSize" of the root graph color (tlp.ColorProperty) : a property linked to the "viewColor" of the root graph regPositive (tlp.BooleanProperty) : a property linked to the positive regulation of a gene, represented by the edges regPositive (tlp.BooleanProperty) : a property linked to the negative regulation of a gene, represented by the edges layout (tlp.LayoutProperty) : a property linked to the "viewLayout" of the root graph labelColor (tlp.ColorProperty) : a property linked to the "viewLabelColor" of the root graph labelBorderColor (tlp.ColorProperty) : a property linked to the "viewLabelBorderColor" of the root graph Returns: None """ tlpgui.closeAllViews() createView(graph) for edge in graph.getEdges(): if(regNegative[edge] == True and regPositive[edge] == False): color[edge] = tlp.Color.Red elif(regNegative[edge] == False and regPositive[edge] == True): color[edge] = tlp.Color.Green elif(regNegative[edge] == True and regPositive[edge] == True): color[edge] = tlp.Color.Blue else: color[edge] = tlp.Color.Amber label.copy(locus) color.setAllNodeValue(tlp.Color.Gray) labelColor.setAllNodeValue(tlp.Color.SlateGray) labelBorderColor.setAllNodeValue(tlp.Color.SlateGray) size.setAllNodeValue(tlp.Size(5,5,5)) graph.applyLayoutAlgorithm("Random layout",layout)
def pretraitement(graph, Locus, Negative, Positive, viewBorderColor, viewLabel, viewLayout, viewSize): for n in graph.getNodes(): print(n) size = 1000 for n in graph.getNodes(): x = random.random() * size y = random.random() * size viewLayout[n] = tlp.Coord(x, y, 0) viewSize[n] = tlp.Size(10, 10, 10) viewLabel[n] = Locus[n] for n in graph.getEdges(): if Negative[n] == True: if Positive[n] == True: viewBorderColor[n] = tlp.Color.Blue else: viewBorderColor[n] = tlp.Color.Green elif Positive[n] == True: viewBorderColor[n] = tlp.Color.Red else: viewBorderColor[n] = tlp.Color.Violet
def rotate_generalized_ns(graph): root = graph.getRoot() view_layout = root.getLayoutProperty(VIEW_LAYOUT) for n in (n for n in graph.getNodes() if graph.isMetaNode(n) and root[TYPE][n] in [TYPE_REACTION, TYPE_SPECIES]): lo = view_layout[n] meta_neighbours = lambda nodes: sorted( (t for t in nodes if root.isMetaNode(t)), key=lambda t: -root[VIEW_META_GRAPH][t].numberOfNodes()) o_n_1 = meta_neighbours(graph.getInNodes(n)) o_n_2 = meta_neighbours(graph.getOutNodes(n)) if not o_n_1: alpha = get_alpha(lo, view_layout[o_n_2[0]]) if o_n_2 else 0 elif not o_n_2: alpha = get_alpha(view_layout[o_n_1[0]], lo) else: alpha = get_alpha(view_layout[o_n_1[0]], view_layout[o_n_2[0]]) # if the nodes are aligned horizontally, the labels overlap, # so let's avoid such a situation if abs(alpha % 180) == 90: alpha += 45 mg = root[VIEW_META_GRAPH][n] # the diagonal length is larger than the side for squares if abs(alpha % 90) == 45 and TYPE_SPECIES != root[TYPE][n]: n_h = root[VIEW_SIZE][n].getH() / 2 view_layout.translate(tlp.Coord(0, n_h * (1 - sqrt(2))), mg) view_layout.scale(tlp.Coord(0, sqrt(2)), mg) view_layout.rotateZ(-alpha, mg) # as Tulip considers everything to be a square when opening meta nodes, # and spreads the nodes along the diagonal, # we'd rather pretend that our node was slightly smaller if TYPE_SPECIES == root[TYPE][n] and abs(alpha % 90) != 0: r = root[VIEW_SIZE][n].getW() / sqrt(2) root[VIEW_SIZE][n] = tlp.Size(r, r)
def setNodesSize(g, size): nodeSize = tlp.Size(NODE_WIDTH, NODE_HEIGHT, 0) for node in g.getNodes(): size[node] = nodeSize
def buildHeatMap(graph, heatmap, all_tp, cluster_metric): viewSize = graph.getSizeProperty("viewSize") viewColor = graph.getColorProperty("viewColor") viewLayout = graph.getLayoutProperty("viewLayout") viewBorderColor = graph.getColorProperty("viewBorderColor") clusters = getClusters(graph, cluster_metric) print(clusters) # Recherche de la valeur d'expression min et max pour l'intensité de couleur du heatmap # On met graph en parametre pour bien prendre en compte seulement les niveaux d'expression du graph pour lequel on fait le heatmap # Si jamais on a filtré ce graph là , le max ou min peut différer du graph original minimum = all_tp[0].getNodeMin(graph) maximum = all_tp[0].getNodeMax(graph) for tp in all_tp: minimum = all_tp[0].getNodeMin( graph) if all_tp[0].getNodeMin(graph) < minimum else minimum maximum = all_tp[0].geNodetMax( graph) if all_tp[0].getNodeMax(graph) < maximum else maximum print(minimum) print(maximum) heatmap.clear() # Remove all nodes, edges and sub-graphs from the graph heatmap_color = tlp.ColorScale( [tlp.Color.Green, tlp.Color.Black, tlp.Color.Red]) y_step = 2 x_step = 100 print("start") yi = 0 for c in clusters: yi += 20 for n in clusters[c]: yi += y_step xi = 0 for tp in all_tp: xi += x_step new_n = heatmap.addNode() viewSize[new_n] = tlp.Size(x_step, y_step, 1) viewLayout[new_n] = tlp.Coord(xi, yi, 0) # pos = (tp[n] - minimum) / (maximum - minimum) viewColor[new_n] = heatmap_color.getColorAtPos(pos) viewBorderColor[new_n] = heatmap_color.getColorAtPos(pos) # Ajout de la legende tp dans le heatmap viewLabel = heatmap.getStringProperty("viewLabel") viewLabelPosition = heatmap.getIntegerProperty("viewLabelPosition") viewFontSize = heatmap.getIntegerProperty("viewFontSize") xi = 0 yi = -y_step * 40 print(yi) # display number of TP at the bottom of the heatmap for i in range(len(all_tp)): xi += x_step new_n = heatmap.addNode() viewLabel[new_n] = str(i + 1) viewLayout[new_n] = tlp.Coord(xi, yi, 1) viewFontSize[new_n] = 400 viewSize[new_n] = tlp.Size(x_step, y_step * 40, 1) viewColor[new_n] = tlp.Color.White viewBorderColor[new_n] = tlp.Color.White
def draw(): """Draw all the methods of the list in subgraphs and color its nodes accordingly to their expression status. Assemble all the subgraphs in one parallel view """ # Check if all the methods are complete to draw them for method in Method.methodLines: if not method.is_complete(): return False # Copy the original graph in a subgraph to keep it intact source = self.graph.addSubGraph("Source") copy_graph(source, self.graph) # Create a sibling graph of source which will get all the duplicated subgraphs parallel_multi_graph = self.graph.addSubGraph( "Parallel Methods Analysis") for method in Method.methodLines: # Create a duplicated subgraph subgraph = parallel_multi_graph.addSubGraph( name=str(method)) copy_graph(subgraph, source) name_to_node = { } # Dictionary to associate a gene name to its node # Set all nodes and edges of the subgraph to a neutral color viewColor = subgraph.getColorProperty('viewColor') viewSize = subgraph.getSizeProperty("viewSize") viewColor.setAllEdgeValue(tlp.Color(128, 128, 128, 50)) for node in subgraph.getNodes(): viewColor[node] = tlp.Color(128, 128, 128, 50) name_to_node[subgraph.getNodePropertiesValues(node) ["name"]] = node # Get up regulated gene names described by the current method by a cypher query up_regulated = [ result["name"] for result in neo_graph.run( "MATCH " + method.cypher + "--(:Group {name:'up'})--(a) RETURN a.name as name" ) ] # Emphasize the up regulated nodes for name in up_regulated: if name in name_to_node: # If the current graph have this gene viewColor[name_to_node[name]] = tlp.Color( 0, 204, 0, 255) # Set the node green viewSize.setNodeValue(name_to_node[name], tlp.Size( 10, 10, 10)) # Make it bigger # Get down regulated gene names described by the current method by a cypher query down_regulated = [ result["name"] for result in neo_graph.run( "MATCH " + method.cypher + "--(:Group {name:'down'})--(a) RETURN a.name as name" ) ] # Emphasize the up regulated nodes for name in down_regulated: if name in name_to_node: # If the current graph have this gene viewColor[name_to_node[name]] = tlp.Color( 204, 0, 0, 255) # Set the node red viewSize.setNodeValue(name_to_node[name], tlp.Size( 10, 10, 10)) # Make it bigger # Align the different sub graphs on a grid layout subgraph_grid(parallel_multi_graph, self.dataSet["# Columns"]) # Set a view of the parallel multi graph and get its parameters node_link_view = tlpgui.createNodeLinkDiagramView( parallel_multi_graph) rendering_parameters = node_link_view.getRenderingParameters() background = node_link_view.state() scene = background['scene'] rendering_parameters.setEdgeColorInterpolate( True) # Set edge color interpolating from the node ones rendering_parameters.setLabelsDensity( -100) # Don't show any label scene = scene.replace( "<background>(255,255,255,255)</background>", # Set the background to black "<background>(0,0,0,255)</background>") # Apply the changed parameters background['scene'] = scene node_link_view.setState(background) node_link_view.setRenderingParameters(rendering_parameters) # Finish the plugin execution root.destroy()
def random_size(): return tlp.Size(rand_c_float(), rand_c_float(), rand_c_float())
def initLayout(graph, size, layout): new_size = tlp.Size(1.0,1.0,1.0) size.setAllNodeValue(new_size, graph) graph.applyLayoutAlgorithm('Circular', layout)