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 run(self): p = parameters_value d = self.dataSet p[boolean_param_name] = d[boolean_param_name] p[int_param_name] = d[int_param_name] p[float_param_name] = d[float_param_name] p[string_param_name] = d[string_param_name] p[string_collection_param_name] = d[string_collection_param_name] p[color_param_name] = tlp.Color(d[color_param_name]) p[color_scale_param_name] = tlp.ColorScale(d[color_scale_param_name]) p[boolean_prop_param_name] = d[boolean_prop_param_name] p[color_prop_param_name] = d[color_prop_param_name] p[double_prop_param_name] = d[double_prop_param_name] p[int_prop_param_name] = d[int_prop_param_name] p[layout_prop_param_name] = d[layout_prop_param_name] p[size_prop_param_name] = d[size_prop_param_name] p[string_prop_param_name] = d[string_prop_param_name] p[boolean_vec_prop_param_name] = d[boolean_vec_prop_param_name] p[color_vec_prop_param_name] = d[color_vec_prop_param_name] p[double_vec_prop_param_name] = d[double_vec_prop_param_name] p[int_vec_prop_param_name] = d[int_vec_prop_param_name] p[coord_vec_prop_param_name] = d[coord_vec_prop_param_name] p[size_vec_prop_param_name] = d[size_vec_prop_param_name] p[string_vec_prop_param_name] = d[string_vec_prop_param_name] d[out_boolean_param_name] = out_boolean_param_value d[out_int_param_name] = out_int_param_value d[out_float_param_name] = out_float_param_value d[out_string_param_name] = out_string_param_value return True
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 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 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 colorHeatmap(graph): viewBorderColor = graph.getColorProperty("viewBorderColor") viewColor = graph.getColorProperty("viewColor") expression_lvl = graph.getDoubleProperty("Expression_lvl") min_lvl = expression_lvl.getNodeDoubleMin() max_lvl = expression_lvl.getNodeDoubleMax() colorScale = tlp.ColorScale([]) colors = [tlp.Color.Yellow, tlp.Color.Red] colorScale.setColorScale(colors) for n in graph.getNodes(): viewColor[n] = colorScale.getColorAtPos( (expression_lvl[n] - min_lvl) / (max_lvl - min_lvl)) viewBorderColor[n] = viewColor[n]
def colorHeatmap(graph): ''' Colore la Heatmap en fonction de l'expression du gène. Les couleurs vont de jaune (faible expression) à rouge (forte expression) ''' viewBorderColor = graph.getColorProperty("viewBorderColor") viewColor = graph.getColorProperty("viewColor") expression_lvl=graph.getDoubleProperty("Expression_lvl") min_lvl = expression_lvl.getNodeDoubleMin() max_lvl = expression_lvl.getNodeDoubleMax() colorScale = tlp.ColorScale([]) colors = [tlp.Color.Yellow, tlp.Color.Red] colorScale.setColorScale(colors) for n in graph.getNodes(): viewColor[n]=colorScale.getColorAtPos((expression_lvl[n]-min_lvl)/(max_lvl-min_lvl)) viewBorderColor[n]=viewColor[n]
def run(self): parameters_value[boolean_param_name] = self.dataSet[boolean_param_name] parameters_value[int_param_name] = self.dataSet[int_param_name] parameters_value[float_param_name] = self.dataSet[float_param_name] parameters_value[string_param_name] = self.dataSet[string_param_name] parameters_value[string_collection_param_name] = self.dataSet[ string_collection_param_name] parameters_value[color_param_name] = tlp.Color( self.dataSet[color_param_name]) parameters_value[color_scale_param_name] = tlp.ColorScale( self.dataSet[color_scale_param_name]) parameters_value[boolean_prop_param_name] = self.dataSet[ boolean_prop_param_name] parameters_value[color_prop_param_name] = self.dataSet[ color_prop_param_name] parameters_value[double_prop_param_name] = self.dataSet[ double_prop_param_name] parameters_value[int_prop_param_name] = self.dataSet[ int_prop_param_name] parameters_value[layout_prop_param_name] = self.dataSet[ layout_prop_param_name] parameters_value[size_prop_param_name] = self.dataSet[ size_prop_param_name] parameters_value[string_prop_param_name] = self.dataSet[ string_prop_param_name] parameters_value[boolean_vec_prop_param_name] = self.dataSet[ boolean_vec_prop_param_name] parameters_value[color_vec_prop_param_name] = self.dataSet[ color_vec_prop_param_name] parameters_value[double_vec_prop_param_name] = self.dataSet[ double_vec_prop_param_name] parameters_value[int_vec_prop_param_name] = self.dataSet[ int_vec_prop_param_name] parameters_value[coord_vec_prop_param_name] = self.dataSet[ coord_vec_prop_param_name] parameters_value[size_vec_prop_param_name] = self.dataSet[ size_vec_prop_param_name] parameters_value[string_vec_prop_param_name] = self.dataSet[ string_vec_prop_param_name] self.dataSet[out_boolean_param_name] = out_boolean_param_value self.dataSet[out_int_param_name] = out_int_param_value self.dataSet[out_float_param_name] = out_float_param_value self.dataSet[out_string_param_name] = out_string_param_value return True
def echelle_couleur(): # On crée la liste des couleurs optimales # On se base sur le site suivant # https://colorbrewer2.org/#type=qualitative&scheme=Paired&n=12 colors = [] colors.append(tlp.Color(166, 206, 227)) colors.append(tlp.Color(251, 154, 153)) colors.append(tlp.Color(177, 89, 40)) colors.append(tlp.Color(51, 160, 44)) colors.append(tlp.Color(202, 178, 214)) colors.append(tlp.Color(253, 191, 111)) colors.append(tlp.Color(31, 120, 180)) colors.append(tlp.Color(255, 255, 153)) colors.append(tlp.Color(227, 26, 28)) colors.append(tlp.Color(178, 223, 138)) colors.append(tlp.Color(255, 127, 0)) colors.append(tlp.Color(106, 61, 154)) return (tlp.ColorScale(colors))
def color_graph(gr, param, color): """ Realize a coloring of the graph gr according to the values of param. @type gr: tlp.Graph @param r: Current graph @type param: tlp.DoubleProperty @param param: Property responsible for color (input property) @type color: tlp.ColorProperty @param color: a graph viewColor property """ 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 colorNodes(graph, doubleMetric): """ Function to set a color for each node in the graph, depending on their respective value in the double metric property To color the nodes, this function uses the "Color Mapping" algorithm from Tulip, with the double metric values as input properties. Args: graph (tlp.Graph) : the graph where the color mapping will process on doubleMetric (tlp.DoubleProperty) : a property linked to any double properties from the graph Returns: None """ colorProp = graph.getColorProperty("viewColor") colorScale = tlp.ColorScale([]) colors = [tlp.Color.Green, tlp.Color.Black, tlp.Color.Red] colorScale.setColorScale(colors) param = tlp.getDefaultPluginParameters("Color Mapping", graph) param["input property"] = doubleMetric param["color scale"] = colorScale graph.applyColorAlgorithm("Color Mapping", colorProp, param)
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 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)
color_scale_param_name = 'color_scale' color_scale_param_default_value = '((255,0,0,255),(0,255,0,255),(0,0,255,255))' color_scale_default_value_dict = { 0.0: (255, 0, 0, 255), 0.5: (0, 255, 0, 255), 1.0: (0, 0, 255, 255) } color_scale_param_value_dict = { 0.0: (255, 0, 255, 255), 0.5: (128, 255, 0, 255), 1.0: (128, 0, 255, 255) } color_scale_param_value_list = [(255, 0, 255, 255), (128, 255, 0, 255), (128, 0, 255, 255)] color_scale_param_value = tlp.ColorScale(color_scale_param_value_dict) dir_param_name = 'dir' dir_param_default_value = '/tmp' dir_param_value = '/home/toto' file_param_name = 'file' file_param_default_value = '/tmp/foo.csv' file_param_value = '/home/toto/bar.csv' string_collection_param_name = 'string collection' string_collection_param_default_value = 'foo;bar' string_collection_param_value = 'bar' out_boolean_param_name = 'bool_out' out_boolean_param_value = True
# Compute an anonymous degree property degree = tlp.DoubleProperty(graph) degreeParams = tlp.getDefaultPluginParameters("Degree") graph.applyDoubleAlgorithm("Degree", degree, degreeParams) # Map the node sizes to their degree sizeMappingParams = tlp.getDefaultPluginParameters("Metric Mapping", graph) sizeMappingParams["property"] = degree sizeMappingParams["min size"] = 1 sizeMappingParams["max size"] = 30 graph.applySizeAlgorithm("Metric Mapping", viewSize, sizeMappingParams) # Create a heat map color scale heatMap = tlp.ColorScale( [tlp.Color(0, 255, 0), tlp.Color(0, 0, 0), tlp.Color(255, 0, 0)]) # Map the node colors to their degree using the heat map color scale # Also set the nodes labels to their id for n in graph.getNodes(): viewColor[n] = heatMap.getColorAtPos( (degree[n] - degree.getNodeMin()) / (degree.getNodeMax() - degree.getNodeMin())) viewLabel[n] = str(n.id) # Add a border to edges viewBorderWidth.setAllEdgeValue(1) # Create a Node Link Diagram view and set some rendering parameters nodeLinkView = tlp.addNodeLinkDiagramView(graph)