annotate smart_toolShed/SMART/Java/Python/misc/RPlotter.py @ 4:1fc014126d55

Uploaded

1 #
2 # Copyright INRA-URGI 2009-2010
3 # 
4 # This software is governed by the CeCILL license under French law and
5 # abiding by the rules of distribution of free software. You can use,
6 # modify and/ or redistribute the software under the terms of the CeCILL
7 # license as circulated by CEA, CNRS and INRIA at the following URL
8 # "http://www.cecill.info".
9 # 
10 # As a counterpart to the access to the source code and rights to copy,
11 # modify and redistribute granted by the license, users are provided only
12 # with a limited warranty and the software's author, the holder of the
13 # economic rights, and the successive licensors have only limited
14 # liability.
15 # 
16 # In this respect, the user's attention is drawn to the risks associated
17 # with loading, using, modifying and/or developing or reproducing the
18 # software by the user in light of its specific status of free software,
19 # that may mean that it is complicated to manipulate, and that also
20 # therefore means that it is reserved for developers and experienced
21 # professionals having in-depth computer knowledge. Users are therefore
22 # encouraged to load and test the software's suitability as regards their
23 # requirements in conditions enabling the security of their systems and/or
24 # data to be ensured and, more generally, to use and operate it in the
25 # same conditions as regards security.
26 # 
27 # The fact that you are presently reading this means that you have had
28 # knowledge of the CeCILL license and that you accept its terms.
29 #
30 
31 import os
32 import subprocess
33 import random
34 import math
35 
36 minPositiveValue = 10e-6
37 
38 """
39 Plot simple curves in R
40 """
41 
42 class RPlotter(object):
43     """
44     Plot some curves
45     @ivar nbColors: number of different colors
46     @type nbColors: int
47     @ivar fileName: name of the file
48     @type fileName: string
49     @ivar lines: lines to be plotted
50     @type lines: array of dict
51     @ivar names: name of the lines
52     @type names: array of strings
53     @ivar colors: color of the lines
54     @type colors: array of strings
55     @ivar types: type of the lines (plain or dashed)
56     @type types: array of strings
57     @ivar format: format of the picture
58     @type format: string
59     @ivar lineWidth: width of the line in a xy-plot
60     @type lineWidth: int
61     @ivar xMin: minimum value taken on the x-axis
62     @type xMin: int
63     @ivar xMax: maximum value taken on the x-axis
64     @type xMax: int
65     @ivar yMin: minimum value taken on the y-axis
66     @type yMin: int
67     @ivar yMax: maximum value taken on the y-axis
68     @type yMax: int
69     @ivar minimumX: minimum value allowed on the x-axis
70     @type minimumX: int
71     @ivar maximumX: maximum value allowed on the x-axis
72     @type maximumX: int
73     @ivar minimumY: minimum value allowed on the y-axis
74     @type minimumY: int
75     @ivar maximumY: maximum value allowed on the y-axis
76     @type maximumY: int
77     @ivar leftMargin:  add some margin in the left part of the plot
78     @type leftMargin:  float
79     @ivar rightMargin: add some margin in the right part of the plot
80     @type rightMargin: float
81     @ivar downMargin:  add some margin at the top of the plot
82     @type downMargin:  float
83     @ivar upMargin:    add some margin at the bottom of the plot
84     @type upMargin:    float
85     @ivar logX: use log scale on the x-axis
86     @type logX: boolean
87     @ivar logY: use log scale on the y-axis
88     @type logY: boolean
89     @ivar logZ: use log scale on the z-axis (the color)
90     @type logZ: boolean
91     @ival fill: if a value is not given, fill it with given value
92     @type fill: int
93     @ival bucket: cluster the data into buckets of given size
94     @type bucket: int
95     @ival seed: a random number
96     @type seed: int
97     @ival regression: plot a linear regression
98     @type regression: boolean
99     @ival legend: set the legend
00     @type legend: boolean
01     @ival legendBySide: set the legend outside of the plot
02     @type legendBySde: boolean
03     @ival xLabel: label for the x-axis
04     @type xLabel: string
05     @ival yLabel: label for the y-axis
06     @type yLabel: string
07     @ival title: title of the plot
08     @type title: string
09     @ival barplot: use a barplot representation instead
10     @type barplot: boolean
11     @ival points: use a point cloud instead
12     @type points: boolean
13     @ival heatPoints: use a colored point cloud instead
14     @type heatPoints: boolean
15     @ival axesLabels: change the names of the axes
16     @type axesLabels: vector of 2 int to string dict
17     @ival rotateAxesLabels: rotate the axes labels
18     @type rotateAxesLabels: dict of 2 boolean
19     @ival verbosity: verbosity of the class
20     @type verbosity: int
21     @ival keep: keep temporary files
22     @type keep: boolean
23     """
24 
25     def __init__(self, fileName, verbosity = 0, keep = False):
26         """
27         Constructor
28         @param fileName: name of the file to produce
29         @type    fileName: string
30         @param verbosity: verbosity
31         @type    verbosity: int
32         @param keep: keep temporary files
33         @type keep: boolean
34         """
35         self.nbColors = 9
36         self.fileName = fileName
37         self.verbosity = verbosity
38         self.keep = keep
39         self.format = "png"
40         self.fill = None
41         self.bucket = None
42         self.lines = []
43         self.names = []
44         self.colors = []
45         self.types = []
46         self.lineWidth = 1
47         self.xMin = None
48         self.xMax = None
49         self.yMin = None
50         self.yMax = None
51         self.seed = random.randint(0, 10000)
52         self.minimumX = None
53         self.maximumX = None
54         self.minimumY = None
55         self.maximumY = None
56         self.leftMargin   = 0
57         self.rightMargin  = 0
58         self.topMargin    = 0
59         self.bottomMargin = 0
60         self.logX = False
61         self.logY = False
62         self.logZ = False
63         self.regression = False
64         self.width = 1000
65         self.height = 500
66         self.legend = False
67         self.legendBySide = False
68         self.xLabel = ""
69         self.yLabel = ""
70         self.title = None
71         self.points = False
72         self.heatPoints = False
73         self.barplot = False
74         self.axesLabels = {1: None, 2: None}
75         self.rotateAxesLabels = {1: False, 2: False}
76         self.linesToAddBox = ""
77     
78     def __del__(self):
79         """
80         Destructor
81         Remove tmp files
82         """
83         if not self.keep:
84             scriptFileName = "tmpScript-%d.R" % (self.seed)
85             if os.path.exists(scriptFileName):
86                 os.remove(scriptFileName)
87             outputFileName = "%sout" % (scriptFileName)
88             if os.path.exists(outputFileName):
89                 os.remove(outputFileName)
90             nbLines = len(self.lines) + (1 if self.heatPoints else 0)
91             for i in range(nbLines):
92                 if os.path.exists("tmpData-%d-%d.dat" % (self.seed, i)):
93                     os.remove("tmpData-%d-%d.dat" % (self.seed, i))
94 
95         
96     def setMinimumX(self, xMin):
97         """
98         Set the minimum value on the x-axis
99         @param xMin:minimum value on the x-axis
00         @type xMin: int
01         """
02         self.minimumX = xMin
03 
04         
05     def setMaximumX(self, xMax):
06         """
07         Set the maximum value on the x-axis
08         @param xMax: maximum value on the x-axis
09         @type xMax: int
10         """
11         self.maximumX = xMax
12         
13     
14     def setMinimumY(self, yMin):
15         """
16         Set the minimum value on the y-axis
17         @param yMin: minimum value on the y-axis
18         @type yMin: int
19         """
20         self.minimumY = yMin
21 
22         
23     def setMaximumY(self, yMax):
24         """
25         Set the maximum value on the y-axis
26         @param yMax: maximum value on the y-axis
27         @type xmax: int
28         """
29         self.maximumY = yMax
30         
31     
32     def setFill(self, fill):
33         """
34         Fill empty data with given value
35         @param fill: the value to fill with
36         @type fill: int
37         """
38         self.fill = fill
39 
40 
41     def setBuckets(self, bucket):
42         """
43         Cluster the data into buckets of given size
44         @param bucket: the size of the buckets
45         @type bucket: int
46         """
47         self.bucket = bucket
48 
49 
50     def setRegression(self, regression):
51         """
52         Plot a linear regression line
53         @param regression: whether to plot the regression
54         @type  regression: bool
55         """
56         self.regression = regression
57 
58 
59     def setFormat(self, format):
60         """
61         Set the format of the picture
62         @param format: the format
63         @type format: string
64         """
65         if format not in ("png", "pdf", "jpeg", "bmp", "tiff"):
66             raise Exception("Format '%s' is not supported by RPlotter" % (format))
67         self.format = format
68 
69 
70     def setWidth(self, width):
71         """
72         Set the dimensions of the image produced
73         @param width: width of the image
74         @type width: int
75         """
76         self.width = width
77         
78         
79     def setHeight(self, height):
80         """
81         Set the dimensions of the image produced
82         @param height: heigth of the image
83         @type height: int
84         """
85         self.height = height
86         
87         
88     def setImageSize(self, width, height):
89         """
90         Set the dimensions of the image produced
91         @param width: width of the image
92         @type width: int
93         @param height: heigth of the image
94         @type height: int
95         """
96         self.setWidth(width)
97         self.setHeight(height)
98         
99         
00     def setLegend(self, legend, bySide = False):
01         """
02         Print a legend or not
03         @param legend: print a legend
04         @type  legend: boolean
05         @param bySide: put the legend outside of the plot
06         @type  bySide: boolean
07         """
08         self.legend       = legend
09         self.legendBySide = bySide
10 
11 
12     def setXLabel(self, label):
13         """
14         Print a label for the x-axis
15         @param label: the label
16         @type label: string
17         """
18         self.xLabel = label
19         if self.xLabel != None:
20             self.xLabel = self.xLabel.replace("_", " ")
21 
22 
23     def setYLabel(self, label):
24         """
25         Print a label for the y-axis
26         @param label: the label
27         @type label: string
28         """
29         self.yLabel = label
30         if self.yLabel != None:
31             self.yLabel = self.yLabel.replace("_", " ")
32 
33 
34     def addLeftMargin(self, margin):
35         """
36         Increase the size of the space on the left part of the graph
37         @param margin: the space added
38         @type  margin: float
39         """
40         self.leftMargin = margin
41 
42 
43     def addRightMargin(self, margin):
44         """
45         Increase the size of the space on the right part of the graph
46         @param margin: the space added
47         @type  margin: float
48         """
49         self.rightMargin = margin
50 
51 
52     def addTopMargin(self, margin):
53         """
54         Increase the size of the space at the top of the graph
55         TopMargin is a percentage if 0 < TopMargin < 1.
56         TopMargin is a value if TopMargin >= 1.
57         @param margin: the space added
58         @type  margin: float
59         """
60         self.topMargin = margin
61 
62 
63     def addBottomMargin(self, margin):
64         """
65         Increase the size of the space at the bottom of the graph
66         @param margin: the space added
67         @type  margin: float
68         """
69         self.bottomMargin = margin
70 
71 
72     def getNewYMaxWithTopMargin(self):
73         """
74         Return new xMin coordinate with left margin
75         @param xMin: coordinate
76         @type  xMin: float
77         """
78         yMax = self.yMax
79         if 0 < self.topMargin and self.topMargin < 1:
80             topMargin = self.topMargin * self.yMax
81             yMax = self.yMax + topMargin
82         elif self.topMargin >= 1:
83             yMax = self.yMax + self.topMargin
84         return yMax
85 
86 
87     def setTitle(self, title):
88         """
89         Print a title for graph
90         @param title: a title
91         @type title: string
92         """
93         self.title = title
94         if self.title != None:
95             self.title = self.title.replace("_", " ")
96 
97 
98     def setAxisLabel(self, i, labels):
99         """
00         Change x- or y-labels
01         @param i: x for x-label, y for y-label
02         @type  i: string
03         @param labels: new labels
04         @type  labels: int to string dict
05         """
06         i = i.lower()
07         if i not in ("x", "y"):
08             raise Exception("Label name '" + i + "' should by 'x' or 'y' while changing axis labels.")
09         self.axesLabels[{"x": 1, "y": 2}[i]] = labels
10 
11 
12     def rotateAxisLabel(self, i, b = True):
13         """
14         Rotate x- or y-labels
15         @param i: x for x-label, y for y-label
16         @type  i: string
17         @param b: whether the labels should be rotated
18         @type  b: boolean
19         """
20         i = i.lower()
21         if i not in ("x", "y"):
22             raise Exception("Label name '" + i + "' should by 'x' or 'y' while rotating axis labels.")
23         self.rotateAxesLabels[{"x": 1, "y": 2}[i]] = b
24 
25     def setLineWidth(self, width):
26         """
27         Set the line width in a xy-plot
28         @param width: the new line width
29         @type  width: int
30         """
31         self.lineWidth = width
32 
33     def setLog(self, log):
34         """
35         Use log-scale for axes
36         @param log: use log scale
37         @type log: boolean
38         """
39         self.logX = ("x" in log)
40         self.logY = ("y" in log)
41         self.logZ = ("z" in log)
42         
43 
44     def setBarplot(self, barplot):
45         """
46         Use barplot representation instead
47         @param barplot: barplot representation
48         @type barplot: boolean
49         """
50         self.barplot = barplot
51         
52 
53     def setPoints(self, points):
54         """
55         Use points cloud representation instead
56         @param points: points cloud representation
57         @type points: boolean
58         """
59         self.points = points
60         
61 
62     def setHeatPoints(self, heatPoints):
63         """
64         Use points cloud representation with color representing another variable instead
65         @param points: colored points cloud representation
66         @type points: boolean
67         """
68         self.heatPoints = heatPoints
69 
70 
71     def addBox(self, lXCoordList, minY, maxY):
72         for lXCoord in lXCoordList:
73             self.linesToAddBox += "rect(%s,%s,%s,%s,density=50, col='grey',border='transparent')\n" % (lXCoord[0], minY, lXCoord[1], maxY)
74     
75     def addLine(self, line, name = "", color = None):
76         """
77         Add a line 
78         @param line: a line to plot
79         @type line: dict
80         """
81         # prepare data
82         plot = []
83         if self.points or self.heatPoints:
84             values = line.values()
85         elif self.fill == None:
86             values = sorted(line.keys())
87         else:
88             values = range(min(line.keys()), max(line.keys()) + 1)
89             
90         for element in values:
91             if self.points or self.heatPoints:
92                 x = element[0]
93                 y = element[1]
94             else:
95                 x = element
96                 if x not in line:
97                     y = self.fill
98                 else:
99                     y = line[x]
00                 
01             if self.minimumX != None and x < self.minimumX:
02                 continue
03             if self.maximumX != None and x > self.maximumX:
04                 continue
05             
06             if x == None:
07                 raise Exception("Problem! x is None. Aborting...")
08             if y == None:
09                 raise Exception("Problem! y is None. Aborting...")
10             if x == 0 and self.logX:
11                 x = minPositiveValue
12             if y == 0 and self.logY:
13                 y = minPositiveValue
14             if self.xMin == None:
15                 if not self.logX or x != 0:
16                     self.xMin = x
17             else:
18                 if not self.logX or x != 0:
19                     self.xMin = min(self.xMin, x)
20             if self.xMax == None:
21                 self.xMax = x
22             else:
23                 self.xMax = max(self.xMax, x)
24             if self.yMin == None:
25                 if not self.logY or y != 0:
26                     self.yMin = y
27             else:
28                 if not self.logY or y != 0:
29                     if y != "NA":
30                         self.yMin = min(self.yMin, y)
31             if self.yMax == None:
32                 self.yMax = y
33             else:
34                 if y != "NA":
35                     self.yMax = max(self.yMax, y)
36 
37             plot.append((x, y))
38 
39         # cluster the data into buckets
40         if self.bucket != None:
41             buckets = dict([((int(value) / int(self.bucket)) * self.bucket, 0) for value in xrange(min(line.keys()), max(line.keys())+1)])
42             for distance, nb in line.iteritems():
43                 buckets[(int(distance) / int(self.bucket)) * self.bucket] += nb
44             self.yMax = max(buckets.values())
45             plot = []
46             for x, y in buckets.iteritems():
47                 plot.append((x, y))
48 
49         # write file
50         dataFileName = "tmpData-%d-%d.dat" % (self.seed, len(self.lines))
51         dataHandle = open(dataFileName, "w")
52         if not self.heatPoints:
53             plot.sort()
54         for (x, y) in plot:
55             if y != "NA":
56                 dataHandle.write("%f\t%f\n" % (x, y))
57             else:
58                 dataHandle.write("%f\t%s\n" % (x, y))
59         dataHandle.close()
60 
61         self.lines.append(line)
62         self.names.append(name)
63 
64         if color == None:
65             colorNumber = len(self.colors) % (self.nbColors - 1) + 1
66             type = "solid"
67             if len(self.colors) >= self.nbColors:
68                 type = "dashed"
69             color = "colorPanel[%d]" % (colorNumber)
70         else:
71             color = "\"%s\"" % (color)
72             type = "solid"
73         self.colors.append(color)
74         self.types.append(type)
75 
76 
77     def addHeatLine(self, line, name = "", color = None):
78         """
79         Add the heat line 
80         @param line: the line which gives the color of the points
81         @type    line: dict
82         """
83         if not self.heatPoints:
84             raise Exception("Error! Trying to add a heat point whereas not mentioned to earlier! Aborting.")
85             
86         dataFileName = "tmpData-%d-%d.dat" % (self.seed, len(self.lines))
87         dataHandle = open(dataFileName, "w")
88     
89         minimumHeat = min(line.values())
90         maximumHeat = max(line.values())
91         minLogValue = 0.00001
92         log = self.logZ
93         
94         if log:
95             if minimumHeat == 0:
96                 for element in line:
97                     line[element] += minLogValue
98                 minimumHeat += minLogValue
99                 maximumHeat += minLogValue
00             minimumHeat = math.log10(minimumHeat)
01             maximumHeat = math.log10(maximumHeat)
02         
03         coeff = 255.0 / (maximumHeat - minimumHeat)
04 
05         for element in line:
06             value = line[element]
07             if log:
08                 value = math.log10(max(minLogValue, value))
09             dataHandle.write("\"#%02X%02X00\"\n" % (int((value - minimumHeat) * coeff), 255 - int((value - minimumHeat) * coeff)))
10 
11         dataHandle.close()
12         self.names.append(name)
13         if color == None:
14             colorNumber = len(self.colors) % (self.nbColors - 1) + 1
15             type = "solid"
16             if len(self.colors) >= self.nbColors:
17                 type = "dashed"
18             color = "colorPanel[%d]" % (colorNumber)
19         else:
20             color = "\"%s\"" % (color)
21             type = "solid"
22         self.colors.append(color)
23         self.types.append(type)
24 
25 
26     def getScript(self):
27         """
28         Write (unfinished) R script
29         """
30         script = ""
31 
32         xMin = self.xMin - self.leftMargin
33         if self.minimumX != None:
34             xMin = max(xMin, self.minimumX)
35         xMax = self.xMax + self.rightMargin
36         if self.maximumX != None:
37             xMax = min(xMax, self.maximumX)
38         yMin = self.yMin - self.bottomMargin
39         if self.minimumY != None:
40             yMin = self.minimumY
41         yMax = self.getNewYMaxWithTopMargin()
42         if self.maximumY != None:
43             yMax = self.maximumY
44 
45         log = ""
46         if self.logX:
47             log += "x"
48         if self.logY:
49             log += "y"
50         if log != "":
51             log = ", log=\"%s\"" % (log)
52 
53         title = ""
54         if self.title != None:
55             title = ", main = \"%s\"" % (self.title)
56 
57         if self.legend and self.legendBySide:
58             script += "layout(matrix(c(1,2), 1, 2), widths=c(5,1))\n"
59 
60         if self.rotateAxesLabels[2]:
61             script += "par(mar=c(5,12,4,2))\n"
62         else:
63             script += "par(mar=c(5,5,4,2))\n"
64 
65         addAxes = True
66 
67         if self.barplot:
68             script += "data = scan(\"tmpData-%d-0.dat\", list(x = -666, y = -666))\n" % (self.seed)
69             if len(self.lines) == 1:
70                 script += "barplot(data$y, name = data$x, xlab=\"%s\", ylab=\"%s\", ylim = c(%f, %f), cex.axis = 2, cex.names = 2, cex.lab = 2%s%s)\n" % (self.xLabel, self.yLabel, yMin, yMax, title, log)
71                 addAxes = False
72             else:
73                 script += "data1 = scan(\"tmpData-%d-1.dat\", list(x = -666, y = -666))\n" % (self.seed)
74                 script += "barplot(rbind(data$y, data1$y), name = data$x, xlab=\"%s\", ylab=\"%s\", cex.axis = 2, cex.names = 2, cex.lab = 2%s, beside = TRUE, space=c(-1,0), axes = FALSE%s)\n" % (self.xLabel, self.yLabel, title, log)
75         elif self.points:
76             script += "data = scan(\"tmpData-%d-0.dat\", list(x = -666, y = -666))\n" % (self.seed)
77             script += "plot(data$x, data$y, xlab=\"%s\", ylab=\"%s\", cex.axis = 2, cex.lab = 2, axes = FALSE%s%s)\n" % (self.xLabel, self.yLabel, title, log)
78             if self.regression:
79                 x = "log10(data$x)" if self.logX else "data$x"
80                 y = "log10(data$y)" if self.logY else "data$y"
81                 script += "abline(lm(%s ~ %s))\n" % (y, x)
82         elif self.heatPoints:
83             if len(self.lines) != 1:
84                 raise Exception("Error! Bad number of input data! Aborting...")
85             script += "data = scan(\"tmpData-%d-0.dat\", list(x = -666, y = -666))\n" % (self.seed)
86             script += "heatData = scan(\"tmpData-%d-1.dat\", list(x = \"\"))\n" % (self.seed)
87             script += "plot(data$x, data$y, col=heatData$x, xlab=\"%s\", ylab=\"%s\", cex.axis = 2, cex.lab = 2, axes = FALSE%s%s)\n" % (self.xLabel, self.yLabel, title, log)
88             if self.regression:
89                 x = "log10(data$x)" if self.logX else "data$x"
90                 y = "log10(data$y)" if self.logY else "data$y"
91                 script += "abline(lm(%s ~ %s))\n" % (y, x)
92         else:
93             script += "plot(x = NA, y = NA, panel.first = grid(lwd = 1.0), xlab=\"%s\", ylab=\"%s\", xlim = c(%f, %f), ylim = c(%f, %f), cex.axis = 2, cex.lab = 2, axes = FALSE%s%s)\n" % (self.xLabel, self.yLabel, xMin, xMax, yMin, yMax, title, log)
94             for i in range(0, len(self.lines)):
95                 script += "data = scan(\"tmpData-%d-%d.dat\", list(x = -666.666, y = -666.666))\n" % (self.seed, i)
96                 script += "lines(x = data$x, y = data$y, col = %s, lty = \"%s\", lwd = %d)\n" % (self.colors[i], self.types[i], self.lineWidth)
97                 
98             script += self.linesToAddBox
99                 
00         if addAxes:
01             for i in self.axesLabels:
02                 rotation = ", las = 2" if self.rotateAxesLabels[i] else ""
03                 if self.axesLabels[i] == None:
04                     script += "axis(%d, cex.axis = 2, cex.lab = 2%s)\n" % (i, rotation)
05                 else:
06                     oldKeys = ", ".join(["%d" % (key) for key in sorted(self.axesLabels[i].keys())])
07                     newKeys = ", ".join(["\"%s\"" % (self.axesLabels[i][key]) for key in sorted(self.axesLabels[i].keys())])
08                     script += "axis(%d, at=c(%s), lab=c(%s), cex.axis = 2, cex.lab = 2%s)\n" % (i, oldKeys, newKeys, rotation)
09         script += "box()\n"
10 
11         if self.legend:
12             if self.legendBySide:
13                 script += "plot.new()\n"
14                 script += "par(mar=c(0,0,0,0))\n"
15                 script += "plot.window(c(0,1), c(0,1))\n"
16             script += "legends   = c(%s)\n" % ", ".join(["\"%s\"" % name  for name  in self.names])
17             script += "colors    = c(%s)\n" % ", ".join(["%s" %     color for color in self.colors])
18             script += "lineTypes = c(%s)\n" % ", ".join(["\"%s\"" % type  for type  in self.types])
19             if self.legendBySide:
20                 script += "legend(0, 1, legend = legends, xjust = 0, yjust = 1, col = colors, lty = lineTypes, lwd = %d, cex = 1.5, ncol = 1, bg = \"white\")\n" % (self.lineWidth)
21             else:
22                 script += "legend(\"topright\", legend = legends, xjust = 0, yjust = 1, col = colors, lty = lineTypes, lwd = %d, cex = 1.5, ncol = 1, bg = \"white\")\n" % (self.lineWidth)
23 
24         return script
25             
26 
27 
28     def plot(self):
29         """
30         Plot the lines
31         """
32         scriptFileName = "tmpScript-%d.R" % (self.seed)
33         scriptHandle = open(scriptFileName, "w")
34         scriptHandle.write("library(RColorBrewer)\n")
35         scriptHandle.write("colorPanel = brewer.pal(n=%d, name=\"Set1\")\n" % (self.nbColors))
36         scriptHandle.write("%s(%s = \"%s\", width = %d, height = %d, bg = \"white\")\n" % (self.format, "filename" if self.format != "pdf" else "file", self.fileName, self.width, self.height))
37         scriptHandle.write(self.getScript())
38         scriptHandle.write("dev.off()\n")
39         scriptHandle.close()
40         rCommand = "R"
41         if "SMARTRPATH" in os.environ:
42             rCommand = os.environ["SMARTRPATH"]
43         command = "\"%s\" CMD BATCH %s" % (rCommand, scriptFileName)
44         status = subprocess.call(command, shell=True)
45 
46         if status != 0:
47             self.keep = True
48             raise Exception("Problem with the execution of script file %s, status is: %s" % (scriptFileName, status))
49             
50 
51     def getCorrelationData(self):
52         if not self.regression:
53             return ""
54         scriptFileName = "tmpScript-%d.R" % (self.seed)
55         rScript = open(scriptFileName, "w")
56         rScript.write("data = scan(\"tmpData-%d-0.dat\", list(x = -0.000000, y = -0.000000))\n" % (self.seed))
57         x = "log10(data$x)" if self.logX else "data$x"
58         y = "log10(data$y)" if self.logY else "data$y"
59         rScript.write("summary(lm(%s ~ %s))\n" % (y, x))
60         rScript.close()
61         rCommand = "R"
62         if "SMARTRPATH" in os.environ:
63             rCommand = os.environ["SMARTRPATH"]
64         command = "\"%s\" CMD BATCH %s" % (rCommand, scriptFileName)
65         status = subprocess.call(command, shell=True)
66         if status != 0:
67             self.keep = True
68             raise Exception("Problem with the execution of script file %s computing the correlation, status is: %s" % (scriptFileName, status))
69         outputRFile = open("%sout" % (scriptFileName))
70         output      = ""
71         start       = False
72         end         = False
73         for line in outputRFile:
74             if start and "> " in line:
75                 end = True
76             if start and not end:
77                 output += line
78             if "summary" in line:
79                 start = True
80         return output
81 
82 
83     def getSpearmanRho(self):
84         """
85         Get the Spearman rho correlation using R
86         """
87         return None
88         if not self.points and not self.barplot and not self.heatPoints:
89             raise Exception("Cannot compute Spearman rho correlation whereas not in 'points' or 'bar' mode.")
90         
91         scriptFileName = "tmpScript-%d.R" % (self.seed)
92         rScript = open(scriptFileName, "w")
93         rScript.write("library(Hmisc)\n")
94         rScript.write("data = scan(\"tmpData-%d-0.dat\", list(x = -0.000000, y = -0.000000))\n" % (self.seed))
95         rScript.write("spearman(data$x, data$y)\n")
96         rScript.close()
97 
98         rCommand = "R"
99         if "SMARTRPATH" in os.environ:
00             rCommand = os.environ["SMARTRPATH"]
01         command = "\"%s\" CMD BATCH %s" % (rCommand, scriptFileName)
02         status = subprocess.call(command, shell=True)
03 
04         if status != 0:
05             self.keep = True
06             raise Exception("Problem with the execution of script file %s, status is: %s" % (scriptFileName, status))
07 
08         outputRFile = open("%sout" % (scriptFileName))
09         nextLine = False
10         for line in outputRFile:
11             line = line.strip()
12             if nextLine:
13                 if line == "NA":
14                     return None
15                 return float(line)
16                 nextLine = False
17             if line == "rho":
18                 nextLine = True
19 
20         return None