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)