def drawHistogram(data,
mainTitle,
xTitle,
yTitle,
xLim,
yLim=None,
color='cadetblue2'):
from proto.RSetup import robjects
hist = robjects.r.hist
if yLim:
hist(robjects.FloatVector(data),
main=mainTitle,
xlab=xTitle,
ylab=yTitle,
xlim=robjects.FloatVector(xLim),
ylim=robjects.FloatVector(yLim),
col=color)
else:
hist(robjects.FloatVector(data),
main=mainTitle,
xlab=xTitle,
ylab=yTitle,
xlim=robjects.FloatVector(xLim),
col=color)
def _combineResults(self):
StatisticDictSumResSplittable._combineResults(self)
self._result['t1prop'] = float(
self._result['t1coverage']) / self._result['NumBps']
self._result['t2prop'] = float(
self._result['t2coverage']) / self._result['NumBps']
self._result[
'ExpBothBpProportionGivenIndividualBinCoverage'] = self._result[
'ExpBothBpCoverageGivenIndividualBinCoverage'] / self._result[
'NumBps']
self._result[
'ExpBothBpProportionFromGlobalIndividualCoverage'] = self._result[
't1prop'] * self._result['t2prop']
from proto.RSetup import robjects, r
t1Props = [x['t1prop'] for x in self._childResults]
t2Props = [x['t2prop'] for x in self._childResults]
if len(t1Props) > 1:
correlation = float(
r.cor(robjects.FloatVector(t1Props),
robjects.FloatVector(t2Props)))
import numpy
if numpy.isnan(correlation):
correlation = None
correlationPval = None
else:
correlationPval = r(
'function(x,y){res=cor.test(x,y); return(res$p.value)}')(
robjects.FloatVector(t1Props),
robjects.FloatVector(t2Props))
#print 'CORR: ',type(correlation), correlation
else:
correlationPval = correlation = None
self._result['IndividualCoveragePerBinCorrelation'] = correlation
self._result[
'IndividualCoveragePerBinCorrelationPvalue'] = correlationPval
self._result['ObsBpProportionOverlap'] = (
float(self._result['ObsBpOverlap']) /
self._result['NumBps']) if self._result['NumBps'] > 0 else None
self._result['RatioOfObsToExpGivenGlobalCoverages'] = (
self._result['ObsBpProportionOverlap'] /
self._result['ExpBothBpProportionFromGlobalIndividualCoverage']
) if self._result[
'ExpBothBpProportionFromGlobalIndividualCoverage'] > 0 else None
self._result['RatioOfObsToExpGivenIndividualBinCoverages'] = (
self._result['ObsBpProportionOverlap'] /
self._result['ExpBothBpProportionGivenIndividualBinCoverage']
) if self._result[
'ExpBothBpProportionGivenIndividualBinCoverage'] > 0 else None
def drawXYPlot(xData, yData, plotType, xLim, yLim, mainTitle, xTitle, yTitle):
from proto.RSetup import robjects
rPlot = robjects.r.plot
rPlot(xData,
yData,
type=plotType,
xlim=robjects.FloatVector(xLim),
ylim=robjects.FloatVector(yLim),
main=mainTitle,
xlab=xTitle,
ylab=yTitle)
def _customRExecution(self, resDictKey, xlab, main):
from proto.RSetup import r, robjects
xList, yList, xLabel, yLabel = self._getRawData(resDictKey)
xVec = robjects.FloatVector(xList)
yVec = robjects.FloatVector(yList)
rCode = 'plotFunc <- function(xVec, yVec, xlab, ylab, main) {plot(xVec, yVec, type="l", xlab=xlab, ylab=ylab, main=main)}'
#print (xs, ys, xlab, main)
#print 'rawData: ',self._getRawData(resDictKey)
r(rCode)(xVec, yVec, xLabel, yLabel, main)
self._plotResultObject = r('dataFunc <- function(xVec, yVec) {list("x"=xVec, "y"=yVec)}')(xVec, yVec)
def _compute(self):
tv = self._children[0].getResult()
# print tv.genomeAnchor.chr
points = self._children[0].getResult().startsAsNumpyArray()
binSize = self._children[1].getResult()
globalPointCount = self._children[2].getResult()
rCode = '''
k<-function(x,r,a,b,n) {
if (min(x)<a || max(x)>b) stop("Points must be in interval [a,b]!")
dmat<-as.matrix(dist(x)) ## calculate distanced between all pairs of points
diag(dmat)<-Inf ## distance of point to itself (zero) should not be counted, so set this to infinite (i.e., never less than r)
wmat<-outer(x,x,function(x,y) (pmin(b,pmax(x+abs(x-y),a))-pmin(b,pmax(x-abs(x-y),a)))/(2*abs(x-y))) ## calculate edge correction weights
iwmat<-1/wmat ## inverse of edge correction weights
diag(iwmat)<-0 ## distance of point to itself (zero) should not be counted, so set this to zero (i.e., drops out of sum
k<-sum(iwmat*(dmat<r))/n^2 ## final K-function: (sum of inverse weights iw_ij where d_ij<r)/n^2
k/(2*r)
}
'''
if len(points) == 0:
#import numpy
#return numpy.nan
return None
else:
from proto.RSetup import r, robjects
return r(rCode)(robjects.FloatVector(points), self._bpWindow, 0,
binSize, globalPointCount)
def _customRExecution(self, resDictKey, xlab, main):
from proto.RSetup import r, robjects
#rCode = 'ourHist <- function(ourList, xlab, main, numBins) {vec <- unlist(ourList); hist(vec, col="blue", breaks=numBins, xlab=xlab, main=main)}'
rCode = \
'''ourHist <- function(vec, xlab, main, numBins)
{main = paste(strwrap(main, width=60), collapse="\n");
hist(vec, col="blue", breaks=numBins, xlab=xlab, main=main)}'''
#print (self._results.getAllValuesForResDictKey(resDictKey), xlab, main)
rawData = robjects.FloatVector(self._getRawData(resDictKey))
#rawData = [float(x) for x in self._getRawData(resDictKey)]
numBins = max(10, self._getDataPointCount(resDictKey)/5)
'''
import numpy
data = numpy.bincount(self._getRawData(resDictKey))
import quick.webtools.restricted.visualization.visualizationPlots as vp
from proto.hyperbrowser.HtmlCore import HtmlCore
self.__class__.numCount +=1
if self.__class__.numCount==1:
htmlCore = HtmlCore()
htmlCore.begin()
htmlCore.divBegin('plotDiv')
htmlCore.line(vp.addJSlibs())
htmlCore.line(vp.useThemePlot())
htmlCore.line(vp.addJSlibsExport())
htmlCore.line(vp.axaddJSlibsOverMouseAxisisPopup())
seriesType = ['column' for x in list(data)]
#linear scale
"""
htmlCore.line(vp.drawChart(list(data),
tickInterval=None,
type='column',
label='x= {point.x} </br> y= {point.y}',
seriesType=seriesType,
height=400,
titleText='Histogram',
tickMinValue=1,
legend=False,
plotNumber=self.__class__.numCount
))
"""
#log scale
htmlCore.line(vp.drawChart(list(data),
tickInterval=None,
type='column',
label='x= {point.x} </br> y= {point.y}',
seriesType=seriesType,
height=400,
titleText='Histogram',
typeAxisXScale = 'logarithmic',
pointStartLog=1,
legend=False,
plotNumber=self.__class__.numCount
))
htmlCore.divEnd()
htmlCore.end()
print str(htmlCore)
'''
self._plotResultObject = r(rCode)(rawData, xlab, main, numBins)
def countHist(self, newResList):
poissonListMean = []
if len(newResList) != 0:
from proto.RSetup import r, robjects
newResListLog = []
for el in newResList:
if el == 0:
newResListLog.append(0)
else:
newResListLog.append(math.log(el, 10))
# , breaks=ceiling(max(vec)) - floor((min(vec)))
rCode = 'dataRPois <- function(vec) {' \
'hist(vec, prob=T)' \
'}'
dd = robjects.FloatVector(newResListLog)
dataFromRPois = r(rCode)(dd)
breaks = list(dataFromRPois.rx2('breaks'))
try:
counts = list(dataFromRPois.rx2('density'))
except:
counts = [dataFromRPois.rx2('density')]
for elN in range(0, len(counts)):
br = (breaks[elN] + breaks[elN + 1]) / 2
ct = counts[elN]
poissonListMean.append([br, ct])
return poissonListMean
def execute(cls, choices, galaxyFn=None, username=''):
'''Is called when execute-button is pushed by web-user.
Should print output as HTML to standard out, which will be directed to a results page in Galaxy history.
If getOutputFormat is anything else than HTML, the output should be written to the file with path galaxyFn.
If needed, StaticFile can be used to get a path where additional files can be put (e.g. generated image files).
choices is a list of selections made by web-user in each options box.
'''
from time import time
startTime = time()
from quick.application.ExternalTrackManager import ExternalTrackManager
from proto.hyperbrowser.StaticFile import GalaxyRunSpecificFile
motifFn = ExternalTrackManager.extractFnFromGalaxyTN(
choices[0].split(':'))
observedFasta = ExternalTrackManager.extractFnFromGalaxyTN(
choices[1].split(':'))
randomGalaxyTN = choices[2].split(':')
randomName = ExternalTrackManager.extractNameFromHistoryTN(
randomGalaxyTN)
randomGalaxyFn = ExternalTrackManager.extractFnFromGalaxyTN(
randomGalaxyTN)
randomStatic = GalaxyRunSpecificFile(
['random'], randomGalaxyFn
) #finds path to static file created for a previous history element (randomFn), and directs to a folder containing several files..
#print os.listdir(randomStatic.getDiskPath())
randomFastaPath = randomStatic.getDiskPath()
#motifFn, observedFasta, randomFastaPath = '/Users/sandve/egne_dokumenter/_faglig/NullModels/DnaSeqExample/liver.pwm', 'liver.fa', 'randomFastas'
testStatistic = choices[3]
if testStatistic == 'Average of max score per sequence':
scoreFunc = scoreMotifOnFastaAsAvgOfBestScores
elif testStatistic == 'Sum of scores across all positions of all sequences':
scoreFunc = scoreMotifOnFastaAsSumOfAllScores
elif testStatistic == 'Score of Frith et al. (2004)':
scoreFunc = lr4
elif testStatistic == 'Product of max per sequence':
scoreFunc = scoreMotifOnFastaAsProductOfBestScores
else:
raise
pvals = mcPvalFromMotifAndFastas(motifFn, observedFasta,
randomFastaPath, scoreFunc)
print 'Pvals for motifs (%s) against observed (%s) vs random (%s - %s) sequences.' % (
motifFn, observedFasta, randomName, randomFastaPath)
for motif, pval in sorted(pvals.items()):
print motif + '\t' + ('%.4f' % pval)
from proto.hyperbrowser.StaticFile import GalaxyRunSpecificFile
from proto.RSetup import robjects
histStaticFile = GalaxyRunSpecificFile(['pvalHist.png'], galaxyFn)
#histStaticFile.openRFigure()
histStaticFile.plotRHist(pvals.values(), [x / 40.0 for x in range(41)],
'Histogram of p-values',
xlim=robjects.FloatVector([0.0, 1.0]))
#r.hist(robjects.FloatVector(pvals.values()), breaks=robjects.FloatVector([x/40.0 for x in range(41)]), xlim=robjects.FloatVector([0.0, 1.0]), main='Histogram of p-values' )
#histStaticFile.closeRFigure()
print histStaticFile.getLink('Histogram')
print 'Time (s):', time() - startTime
def _compute(self):
from proto.RSetup import r, robjects
summaryStats = robjects.FloatVector([
self._children[0].getResult()[key]
for key in ['Neither', 'Only1', 'Only2', 'Both']
])
r('library("polycor")')
tetraCor = r('function(vec){polychor(matrix(vec, nrow=2))}')
return tetraCor(summaryStats)
def _customRExecution(self, resDictKey, xlab, main):
from proto.RSetup import r, robjects
xs, ys = self._getRawData(resDictKey)
xVec = robjects.FloatVector(xs)
yVec = robjects.FloatVector(ys)
rCode = 'plotFunc <- function(xVec, yVec, xlab, ylab, main) {plot(xVec, yVec, xlab=xlab, ylab=ylab, main=main); lines(lowess(xVec, yVec),col="red")}'
#print (xs, ys, xlab, main)
#print 'rawData: ',self._getRawData(resDictKey)
xlab = 'Stat-values on track1' #rename x-lab for scatter-plot case..
ylab = 'Stat-values on track2'
r(rCode)(xVec, yVec, xlab, ylab, main)
self._plotResultObject = r(
'dataFunc <- function(xVec, yVec) {list("x"=xVec, "y"=yVec)}')(
xVec, yVec)
def drawBarplot(data, mainTitle, xTitle, yTitle, names, col):
from proto.RSetup import robjects
barplot = robjects.r.barplot
barplot(robjects.FloatVector(data),
main=mainTitle,
xlab=xTitle,
ylab=yTitle,
names=names,
col=col)
def plotRHist(self,
vals,
breaks,
main,
saveRawData=True,
alsoOpenAndClose=True,
**kwArgs):
from proto.RSetup import r, robjects
rvals = robjects.FloatVector(vals)
if type(breaks) in [list, tuple]:
rbreaks = robjects.FloatVector(breaks)
else:
rbreaks = breaks
if not 'xlab' in kwArgs:
kwArgs['xlab'] = 'Values'
if alsoOpenAndClose:
self.openRFigure()
histRes = r.hist(rvals, breaks=rbreaks, main=main, **kwArgs)
if saveRawData:
rawFn = self.getDiskPath() + '.raw.txt'
f = open(rawFn, 'w')
f.write('vals <- c(%s)' % ','.join(str(val)
for val in vals) + '\n')
if type(breaks) in [list, tuple]:
f.write('breaks <- c(%s)' % ','.join(str(b)
for b in breaks) + '\n')
else:
f.write('breaks <- %s' % breaks)
f.write('hist(vals, breaks=breaks) \n')
#r('prn=print')
intensities = r('function(r){r$intensities}')(histRes)
f.write('intensities = c(%s)' %
','.join([str(x) for x in intensities]) + '\n')
f.close()
if alsoOpenAndClose:
self.closeRFigure()
def _compute(self):
#try:
track = [None, None]
for i in [0, 1]:
tv = self._children[i].getResult()
track[i] = []
for index, el in enumerate(tv):
if el.start() == el.end() == None:
track[i] += [index, index + 1, float(el.val())]
else:
track[i] += [
int(el.start()),
int(el.end()),
int(float(el.val())) if el.val() is not None else nan
]
#print "track 0 before unlist: " %, track[0]
#print "track 1 before unlist: " % track[1]
header = [
'rCompute <- function(track1, track2) {',
#'track1[unlist(sapply(track1,is.null))] <- NA',
#'track2[unlist(sapply(track2,is.null))] <- NA',
#'track1 <- unlist(track1)',
#'track2 <- unlist(track2)',
'dim(track1) <- c(3,' + str(len(track[0]) / 3) + ')',
'dim(track2) <- c(3,' + str(len(track[1]) / 3) + ')',
'result <- 0'
]
footer = ['return(result)', '}']
allLines = header + self._codeLines + footer
from proto.RSetup import r, robjects
track[0] = robjects.FloatVector(track[0])
#print "track 0 after unlist: ", track[0]
track[1] = robjects.FloatVector(track[1])
#print "track 1 after unlist: ", track[1]
return r('\n'.join(allLines))(track[0], track[1])
def drawVioplot(plotDataMatrix, xlabels, mainTitle, xTitle, yTitle,
vioplotColor, xAxisAt, xLimMin, xLimMax, xLas, yAxisAt,
yLimMin, yLimMax, yLas):
from proto.RSetup import robjects
convertedData = [robjects.FloatVector(x) for x in plotDataMatrix]
rplot = robjects.r.plot
axis = robjects.r.axis
from rpy2.robjects.packages import importr
vioplot = importr("vioplot")
rplot([1], [1],
type='n',
xlim=robjects.FloatVector([xLimMin, xLimMax]),
ylim=robjects.FloatVector([yLimMin, yLimMax]),
axes=False,
ann=False)
vioplot.vioplot(col=vioplotColor, add=True, *convertedData)
axis(1, at=xAxisAt, labels=xlabels, las=xLas)
axis(2, at=yAxisAt, las=yLas)
title = robjects.r.title
title(main=mainTitle)
title(xlab=xTitle)
title(ylab=yTitle)
def drawHeatmap(heatmapPlotData, rowLabels, colLabels, mainTitle, symm=True):
"""heatmapPlotData is a matrix represented by a list of lists"""
from proto.RSetup import robjects
from numpy import matrix
heatmap = robjects.r.heatmap
rmatrix = robjects.r.matrix
flatData = matrix(heatmapPlotData).flatten().tolist()[0]
data = robjects.FloatVector(flatData)
heatmap(rmatrix(data, nrow=len(rowLabels)),
labRow=rowLabels,
labCol=colLabels,
main=mainTitle,
symm=symm)
def _compute(self):
from proto.RSetup import robjects, r
#if self._minimal:
# return {'Result': OrderedDict([('Matrix', np.array([], dtype='float64')), \
# ('Rows', np.array([], dtype='S1')), \
# ('Cols', np.array([], dtype='S1'))])}
#
#rawData = self._children[0].getResult()
#edges = rawData.edgesAsNumpyArray()
#weights = rawData.weightsAsNumpyArray()
#ids = rawData.idsAsNumpyArray()
#
#if len(edges) > 0:
# assert all((x==edges[0]).all() for x in edges), 'Edge arrays are not equal for all elements'
#
#x,y = weights.shape
#assert x == y, 'Weight matrix is not square, %s != %s' % (x,y)
graph = self._graphStat.getResult()
res = graph.getEdgeWeightMatrixRepresentation(completeMatrix=self._complete, \
rowsAsFromNodes=self._rowsAsFromNodes, \
missingEdgeWeight=np.nan)
if self._normalizationMethod != 'none':
if self._normalizationMethod == 'log':
res['Matrix'] = np.log(res['Matrix'])
if self._normalizationMethod == 'log+1':
res['Matrix'] = np.log(res['Matrix'] + 1)
elif self._normalizationMethod == 'p_inverse':
res['Matrix'] = 1 - res['Matrix']
else:
origShape = res['Matrix'].shape
if self._normalizationMethod == 'p_to_normal_onesided':
intermed = 1 - res['Matrix']
else: #p_to_normal_twosided
intermed = 1 - res['Matrix'] / 2
vec = robjects.FloatVector(intermed.flatten())
# To remove -Inf anf Inf values
vec = r(
'f <- function(vec){vec[vec==0] = .Machine$double.eps; vec[vec==1] = 1-.Machine$double.eps;vec}'
)(vec)
res['Matrix'] = np.array(list(r.qnorm(vec)))
res['Matrix'].shape = origShape
return {'Result': res}
def getLinkToLocalResultsHeatmap(self, linkText, disease, resDictKey,
galaxyFn):
values = []
allLocalResults = self.getAllLocalResults(resDictKey,
fillInNoneValues=True)
allLocalRegions = self.getLocalRegions()
refSubTypes = self.getRefSubTypes()
numRows = len(allLocalRegions)
for localRegion in allLocalRegions:
for refSubType in refSubTypes:
values.append(allLocalResults[refSubType][localRegion])
if None in values or any(numpy.isnan(x) for x in values):
return 'Not generated, due to missing values'
#if not ( 0 < (float(sum(values)) / len(values)) < 100000):
# return 'Not generated, due to too small/large values (average: %s)' % (float(sum(values)) / len(values))
maxVal = max(values)
from proto.RSetup import r, robjects
r('library(gplots)')
dataMatrix = r.matrix(robjects.FloatVector(values), nrow=numRows)
if (r.length(r.unique(r.colSums(dataMatrix))) <= 1) or (r.length(
r.unique(r.rowSums(dataMatrix))) <= 1):
return 'Not generated, due to lacking variation'
dataMatrix = r('function(data,names){rownames(data)=names; data}')(
dataMatrix, [str(x) for x in allLocalRegions])
dataMatrix = r('function(data,names){colnames(data)=names; data}')(
dataMatrix, refSubTypes)
#print 'dimensions dataMatrix: ', r.dim(dataMatrix), dataMatrix
sf = GalaxyRunSpecificFile(
['LocalResultTables', resDictKey, disease + '_heatmap.png'],
galaxyFn)
sf.openRFigure(h=4000, w=4000)
r("function(data,maxVal){heatmap.2(data,col =c('#99FFFF',colorRampPalette(c('cyan','blue', 'black', 'red', 'yellow'))(161),'#FFFF66'), breaks = seq(0,maxVal,length=164),trace='none',margins=c(15,15))}"
)(dataMatrix, maxVal)
#r("function(data){heatmap(data)}")(dataMatrix)
sf.closeRFigure()
return sf.getLink(linkText)
def drawMultiHistogram(data,
mainTitle,
xTitle,
yTitle,
names=None,
colors=None,
hasLegend=False):
from proto.RSetup import robjects
from rpy2.robjects.packages import importr
plotrix = importr('plotrix')
multhist = plotrix.multhist
legend = robjects.r.legend
plotData = [robjects.FloatVector(x) for x in data]
multhist(plotData,
col=colors,
main=mainTitle,
beside=True,
xlab=xTitle,
ylab=yTitle)
if hasLegend:
legend('topleft', legend=names, pch=15, col=colors, bty='n')
def countPoissonDistribution(self, numMut, intervalLen):
poissonListMean = []
if numMut != 0:
from proto.RSetup import r, robjects
# number of mutation/ length of interval
rCode = 'dataRPois <- function(vec) {' \
'vecNew = log10(rexp(10000, vec[1]/vec[2])); ' \
'data=hist(vecNew, prob=T)' \
'}'
dd = robjects.FloatVector(
[numMut, intervalLen])
dataFromRPois = r(rCode)(dd)
breaks = list(dataFromRPois.rx2('breaks'))
counts = list(dataFromRPois.rx2('density'))
for elN in range(0, len(counts)):
br = (breaks[elN] + breaks[elN + 1]) / 2
ct = counts[elN]
poissonListMean.append([br, ct])
return poissonListMean
def _combineResults(self):
from proto.RSetup import robjects, r
rVec1 = robjects.FloatVector([x[0] for x in self._childResults])
rVec2 = robjects.FloatVector([x[1] for x in self._childResults])
return r.cor(rVec1, rVec2, method=self._corrMethod)
def _customRExecution(self, resDictKey, xlab, main):
from proto.RSetup import r, robjects
rCode = ('ourHeatmap <- function(matrix, rowNames, colNames, rowClust,'
'colClust, dendrogram, marginLeft, '
'marginTop, mapHeight, mapWidth, '
'margins, cex, font, col, breaks, cellnote){'
'dimnames(matrix) <- list(rowNames, colNames); '
'sink(file("/dev/null", open="wt"), type="output"); '
'library(gplots); sink(); options(expressions=100000); '
'if (typeof(rowClust) != "logical") {'
'class(rowClust) = "hclust"; '
'rowClust = as.dendrogram(rowClust)}; '
'if (typeof(colClust) != "logical") {'
'class(colClust) = "hclust"; '
'colClust = as.dendrogram(colClust)}; '
'dim(cellnote) = rev(dim(matrix)); '
'cellnote = t(cellnote); '
'return(heatmap.2(matrix, trace="none", Rowv=rowClust, '
'Colv=colClust, dendrogram=dendrogram, '
'margins=margins, na.rm=TRUE, '
'na.color="white", col=col, breaks=breaks, '
'lhei=c(marginTop,mapHeight), '
'lwid=c(marginLeft,mapWidth), '
'cexRow=cex, cexCol=cex, font=font, '
'key=(min(marginTop, marginLeft) >= 150), '
'keysize=1, cellnote=cellnote, '
'notecex=2, notecol="black"))}')
tableData = self._getRawData(resDictKey)
assert isinstance(tableData, TableData)
matrix = tableData.numpyMatrix
rowNames = tableData.rowNamesAsNumpyArray
colNames = tableData.columnNamesAsNumpyArray
significance = tableData.significanceMatrix
rowClust = tableData.rowClust
colClust = tableData.colClust
rowClust, colClust = [
x if x is not None else False for x in [rowClust, colClust]
]
dendrogram = [["both", "row"],
["column", "none"]][rowClust == False][colClust == False]
hist = numpy.histogram(
matrix, bins=[-numpy.Inf, -1 - 1e-9, 0, 1 + 1e-9, numpy.Inf])[0]
if hist[0] + hist[1] + hist[3] == 0: #Only counts between 0 and 1
col = r("colorRampPalette(c('black', 'red', 'yellow'))")
breaks = 82
elif hist[0] + hist[3] == 0: #Only counts between -1 and 1
col = r(
"colorRampPalette(c('cyan', 'blue', 'black', 'red', 'yellow'))"
)
breaks = 164
#elif hist[0] == 0: #Assume unbalanced score, most values between -1 and 0
# col = r("colorRampPalette(c('blue', 'black', 'red', 'yellow'))")
# matmax = matrix.max()
# breaks = r("function(matmax) {c(seq(-1.02,0.98,length=51), seq(1.02,matmax,length=26))}")(matmax)
elif hist[0] == 0: #Only positive counts
col = r("colorRampPalette(c('black', 'red', 'yellow'))")
breaks = 164
else: #Assumes normal distribution
col = r(
"c('#99FFFF',colorRampPalette(c('cyan','blue', 'black', 'red', 'yellow'))(161),'#FFFF66')"
)
breaks = r("seq(-4.075,4.075,length=164)")
# if numpy.argmax(hist) == 1: #Adjust color palette
# matmax = matrix.max()
# matmin = matrix.min()
# if matmin < -1.0:
# breaks = numpy.arange(matmin,-1.0,(-1.0-matmin)/20)
# withBlack = True
# else:
# breaks = numpy.array([])
# withBlack = False
# breaks = numpy.concatenate((breaks, \
# numpy.arange(-1,1,1.0/20)))
# if matmax > 1.0:
# breaks = numpy.concatenate((breaks, \
# numpy.arange(1, matmax, (matmax-1.0)/20), \
# numpy.array([matmax])))
# withWhite = True
# else:
# breaks = numpy.concatenate((breaks, \
# numpy.array([1.0])))
# withWhite = False
# rFunc = '''
#function(numCols, withBlack, withWhite) {
# cols = c("red","orange","yellow")
# if(withBlack) {
# cols = c("black", cols)
# }
# if(withWhite) {
# cols = c(cols, "white")
# }
# colorRampPalette(cols)(numCols)
#}'''
# col = r(rFunc)(len(breaks)-1, withBlack, withWhite)
#else:
# col = 'heat.colors'
# breaks = 80
cellnote = numpy.zeros(shape=matrix.shape, dtype='S1')
if significance is not None:
cellnote[significance] = 'o'
self._returnDict[resDictKey] = \
r(rCode)(matrix, [x for x in rowNames], [x for x in colNames], rowClust, colClust, dendrogram, \
self._marginLeft, self._marginTop, self._mapHeight, self._mapWidth, \
robjects.FloatVector(self._getMarginsInLineHeights()), \
self._cex, self.FONT, col, breaks, cellnote.flatten().tolist())
