Merge branch 'testing' of https://github.com/genenetwork/genenetwork2 into production

1 files changed, 3 insertions, 986 deletions

diff --git a/wqflask/utility/Plot.py b/wqflask/utility/Plot.py
index d60e2bb2..529cd117 100644
--- a/wqflask/utility/Plot.py
+++ b/wqflask/utility/Plot.py
@@ -36,11 +36,9 @@ from numarray import linear_algebra as la
 from numarray import ones, array, dot, swapaxes
 
 import reaper
-# sys.path.append("..") Never in a running webserver
-from basicStatistics import corestats
 
-import svg
 import webqtlUtil
+import corestats
 from base import webqtlConfig
 
 import utility.logger
@@ -83,202 +81,6 @@ def frange(start, end=None, inc=1.0):
         L[i] = start + i * inc
     return L
 
-
-def gammln(xx):
-    cof=[76.18009173,-86.50532033,24.01409822,-1.231739516,0.120858003e-2,-0.536382e-5]
-    x=xx-1.0
-    tmp=x+5.5
-    tmp -=(x+0.5)*log(tmp)
-    ser=1.0
-    for item in cof:
-        x+=1.0
-        ser+=item/x
-
-    return -tmp+log(2.50662827465*ser)
-
-
-def gser(a,x):
-    gln=gammln(a)
-    ITMAX=100
-    EPS=3.0e-7
-
-    if x<=0.0:
-        gamser=0.0
-        return [gamser,gln]
-    else:
-        ap=a
-        sum=1.0/a
-        dele=sum
-        for i in range(1,ITMAX+1):
-            ap+=1.0
-            dele*=x/ap
-            sum+=dele
-            if abs(dele)<abs(sum)*EPS:
-                gamser=sum*exp(-x+a*log(x)-gln)
-                return [gamser,gln]
-    return None
-
-def gcf(a,x):
-    ITMAX=100
-    EPS=3.0e-7
-    gold=0.0
-    fac=1
-    b1=1.0
-    b0=0.0
-    a0=1.0
-    gln=gammln(a)
-
-    a1=x
-    for n in range(1,ITMAX+1):
-        an=n+0.0
-        ana=an-a
-        a0=(a1+a0*ana)*fac
-        b0=(b1+b0*ana)*fac
-        anf=an*fac
-        a1=x*a0+anf*a1
-        b1=x*b0+anf*b1
-        if (a1):
-            fac=1.0/a1
-            g=b1*fac
-            if abs((g-gold)/g)<EPS:
-                gammcf=exp(-x+a*log(x)-gln)*g
-                return [gammcf,gln]
-            gold=g
-    return None
-
-def gammp(a,x):
-    if x<0.0 or a<=0.0:
-        return None
-    if x<(a+1.0):
-        a=gser(a,x)[0]
-        return a
-    else:
-        a=gcf(a,x)[0]
-        return 1.0-a
-def U(n):
-    x=pow(0.5,1.0/n)
-    m=[1-x]
-    for i in range(2,n):
-        a=(i-0.3175)/(n+0.365)
-        m.append(a)
-    m.append(x)
-    return m
-
-def erf(x):
-    if x<0.0:
-        return -gammp(0.5,x*x)
-    else:
-        return gammp(0.5,x*x)
-
-def erfcc(x):
-    z=abs(x)
-    t=1.0/(1.0+0.5*z)
-    ans=t*exp(-z*z-1.26551223+t*(1.00002368+t*(0.37409196+t*(0.09678418+t*(-0.18628806+t*(0.27886807+t*(-1.13520398+t*(1.48851587+t*(-0.82215223+t*0.17087277)))))))))
-    if x>=0.0:
-        return ans
-    else:
-        return 2.0-ans
-
-def calMeanVar(data):
-    n=len(data)
-    if n<2:
-        return None
-    else:
-        sum=reduce(lambda x,y:x+y,data,0.0)
-        mean=sum/n
-        z=data[:]
-        for i in range(n):
-            z[i]=z[i]-mean
-        variance=reduce(lambda x,y:x+y*y,z,0.0)
-        variance /= n-1
-        variance =sqrt(variance)
-        for i in range(n):
-            z[i]=z[i]/variance
-        return z
-
-def inverseCumul(p):
-    #Coefficients in rational approximations.
-    a = [-3.969683028665376e+01,2.209460984245205e+02,-2.759285104469687e+02,1.383577518672690e+02,-3.066479806614716e+01,2.506628277459239e+00]
-
-    b = [-5.447609879822406e+01,1.615858368580409e+02,-1.556989798598866e+02,6.680131188771972e+01,-1.328068155288572e+01]
-
-    c = [-7.784894002430293e-03,-3.223964580411365e-01,-2.400758277161838e+00,-2.549732539343734e+00,4.374664141464968e+00,2.938163982698783e+00]
-
-    d =  [7.784695709041462e-03,3.224671290700398e-01,2.445134137142996e+00,3.754408661907416e+00]
-
-    #Define break-points.
-
-    p_low  = 0.02425
-    p_high = 1 - p_low
-
-    #Rational approximation for lower region.
-
-    if p > 0 and p < p_low:
-        q = sqrt(-2*log(p))
-        x = (((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) / ((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1)
-
-
-    #Rational approximation for central region.
-
-    elif p>= p_low and p <= p_high:
-        q = p - 0.5
-        r = q*q
-        x = (((((a[0]*r+a[1])*r+a[2])*r+a[3])*r+a[4])*r+a[5])*q /(((((b[0]*r+b[1])*r+b[2])*r+b[3])*r+b[4])*r+1)
-
-    #Rational approximation for upper region.
-
-    elif p>p_high and  p < 1:
-        q = sqrt(-2*log(1-p))
-        x = -(((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5]) /((((d[0]*q+d[1])*q+d[2])*q+d[3])*q+1)
-
-    else:
-        return None
-
-    if p>0 and p < 1:
-        e = 0.5 * erfcc(-x/sqrt(2)) - p
-        u = e * sqrt(2*pi) * exp(x*x/2)
-        x = x - u/(1 + x*u/2)
-        return x
-    else:
-        return None
-
-def gmean(lst):
-    N = len(lst)
-    if N == 0:
-        return 0
-    else:
-        return (reduce(lambda x,y: x+y, lst, 0.0))/N
-
-def gmedian(lst2):
-    lst = lst2[:]
-    N = len(lst)
-    if N == 0:
-        return 0
-    else:
-        lst.sort()
-        if N % 2 == 0:
-            return (lst[N/2]+lst[(N-2)/2])/2.0
-        else:
-            return lst[(N-1)/2]
-
-def gpercentile(lst2, np):
-    """Obsolete - use percentile in corestats instead"""
-    lst = lst2[:]
-    N = len(lst)
-    if N == 0 or np > 100 or np < 0:
-        return None
-    else:
-        lst.sort()
-        pNadd1 = (np/100.0)*N
-        k = int(pNadd1)
-        d = pNadd1 - k
-        if k == 0:
-            return lst[0]
-        elif k >= N-1:
-            return lst[N-1]
-        else:
-            return lst[k-1] + d*(lst[k] - lst[k-1])
-
 def find_outliers(vals):
     """Calculates the upper and lower bounds of a set of sample/case values
 
@@ -315,165 +117,6 @@ def find_outliers(vals):
     logger.debug(pf(locals()))
     return upper_bound, lower_bound
 
-
-def plotBoxPlot(canvas, data, offset= (40, 40, 40, 40), XLabel="Category", YLabel="Value"):
-    xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
-    plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
-    plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
-    iValues = []
-    for item in data:
-        for item2 in item[1]:
-            try:
-                iValues.append(item2[1])
-            except:
-                iValues.append(item2)
-
-    #draw frame
-    max_Y = max(iValues)
-    min_Y = min(iValues)
-    scaleY = detScale(min_Y, max_Y)
-    Yll = scaleY[0]
-    Yur = scaleY[1]
-    nStep = scaleY[2]
-    stepY = (Yur - Yll)/nStep
-    stepYPixel = plotHeight/(nStep)
-    canvas.drawRect(plotWidth+xLeftOffset, plotHeight + yTopOffset, xLeftOffset, yTopOffset)
-
-    ##draw Y Scale
-    YYY = Yll
-    YCoord = plotHeight + yTopOffset
-    scaleFont=pid.Font(ttf="cour",size=11,bold=1)
-    for i in range(nStep+1):
-        strY = cformat(d=YYY, rank=0)
-        YCoord = max(YCoord, yTopOffset)
-        canvas.drawLine(xLeftOffset,YCoord,xLeftOffset-5,YCoord)
-        canvas.drawString(strY, xLeftOffset -30,YCoord +5,font=scaleFont)
-        YYY += stepY
-        YCoord -= stepYPixel
-
-    ##draw X Scale
-    stepX = plotWidth/len(data)
-    XCoord = xLeftOffset + 0.5*stepX
-    YCoord = plotHeight + yTopOffset
-    scaleFont = pid.Font(ttf="tahoma",size=12,bold=0)
-    labelFont = pid.Font(ttf="tahoma",size=13,bold=0)
-    for item in data:
-        itemname, itemvalue = item
-        canvas.drawLine(XCoord, YCoord,XCoord, YCoord+5, color=pid.black)
-        canvas.drawString(itemname, XCoord - canvas.stringWidth(itemname,font=labelFont)/2.0,\
-        YCoord +20,font=labelFont)
-
-        nValue = len(itemvalue)
-        catValue = []
-        for item2 in itemvalue:
-            try:
-                tstrain, tvalue = item2
-            except:
-                tvalue = item2
-            if nValue <= 4:
-                canvas.drawCross(XCoord, plotHeight + yTopOffset - (tvalue-Yll)*plotHeight/(Yur - Yll), color=pid.red,size=5)
-            else:
-                catValue.append(tvalue)
-        if catValue != []:
-            catMean = gmean(catValue)
-            catMedian = gmedian(catValue)
-            lowHinge = gpercentile(catValue, 25)
-            upHinge = gpercentile(catValue, 75)
-            Hstep = 1.5*(upHinge - lowHinge)
-
-            outlier = []
-            extrem = []
-
-            upperAdj = None
-            for item in catValue:
-                if item >= upHinge + 2*Hstep:
-                    extrem.append(item)
-                elif item >= upHinge + Hstep:
-                    outlier.append(item)
-                elif item > upHinge and  item < upHinge + Hstep:
-                    if upperAdj == None or item > upperAdj:
-                        upperAdj = item
-                else:
-                    pass
-            lowerAdj = None
-            for item in catValue:
-                if item <= lowHinge - 2*Hstep:
-                    extrem.append(item)
-                elif item <= lowHinge - Hstep:
-                    outlier.append(item)
-                if item < lowHinge and  item > lowHinge - Hstep:
-                    if lowerAdj == None or item < lowerAdj:
-                        lowerAdj = item
-                    else:
-                        pass
-            canvas.drawRect(XCoord-20, plotHeight + yTopOffset - (lowHinge-Yll)*plotHeight/(Yur - Yll), \
-                    XCoord+20, plotHeight + yTopOffset - (upHinge-Yll)*plotHeight/(Yur - Yll))
-            canvas.drawLine(XCoord-20, plotHeight + yTopOffset - (catMedian-Yll)*plotHeight/(Yur - Yll), \
-                    XCoord+20, plotHeight + yTopOffset - (catMedian-Yll)*plotHeight/(Yur - Yll))
-            if upperAdj != None:
-                canvas.drawLine(XCoord, plotHeight + yTopOffset - (upHinge-Yll)*plotHeight/(Yur - Yll), \
-                XCoord, plotHeight + yTopOffset - (upperAdj-Yll)*plotHeight/(Yur - Yll))
-                canvas.drawLine(XCoord-20, plotHeight + yTopOffset - (upperAdj-Yll)*plotHeight/(Yur - Yll), \
-                XCoord+20, plotHeight + yTopOffset - (upperAdj-Yll)*plotHeight/(Yur - Yll))
-            if lowerAdj != None:
-                canvas.drawLine(XCoord, plotHeight + yTopOffset - (lowHinge-Yll)*plotHeight/(Yur - Yll), \
-                XCoord, plotHeight + yTopOffset - (lowerAdj-Yll)*plotHeight/(Yur - Yll))
-                canvas.drawLine(XCoord-20, plotHeight + yTopOffset - (lowerAdj-Yll)*plotHeight/(Yur - Yll), \
-                XCoord+20, plotHeight + yTopOffset - (lowerAdj-Yll)*plotHeight/(Yur - Yll))
-
-            outlierFont = pid.Font(ttf="cour",size=12,bold=0)
-            if outlier != []:
-                for item in outlier:
-                    yc = plotHeight + yTopOffset - (item-Yll)*plotHeight/(Yur - Yll)
-                    #canvas.drawEllipse(XCoord-3, yc-3, XCoord+3, yc+3)
-                    canvas.drawString('o', XCoord-3, yc+5, font=outlierFont, color=pid.orange)
-            if extrem != []:
-                for item in extrem:
-                    yc = plotHeight + yTopOffset - (item-Yll)*plotHeight/(Yur - Yll)
-                    #canvas.drawEllipse(XCoord-3, yc-3, XCoord+3, yc+3)
-                    canvas.drawString('*', XCoord-3, yc+6, font=outlierFont, color=pid.red)
-
-            canvas.drawCross(XCoord, plotHeight + yTopOffset - (catMean-Yll)*plotHeight/(Yur - Yll), \
-                    color=pid.blue,size=3)
-            #print(catMean, catMedian, cat25per, cat75per)
-            pass
-
-        XCoord += stepX
-
-    labelFont=pid.Font(ttf="verdana",size=18,bold=0)
-    canvas.drawString(XLabel, xLeftOffset + (plotWidth -canvas.stringWidth(XLabel,font=labelFont))/2.0, \
-    YCoord +40, font=labelFont)
-    canvas.drawString(YLabel,xLeftOffset-40, YCoord-(plotHeight -canvas.stringWidth(YLabel,font=labelFont))/2.0,\
-     font=labelFont, angle =90)
-
-def plotSecurity(canvas, text="12345"):
-    if not text:
-        return
-
-    plotWidth = canvas.size[0]
-    plotHeight = canvas.size[1]
-    if plotHeight<=0 or plotWidth<=0:
-        return
-
-    bgColor = pid.Color(0.6+0.4*random.random(), 0.6+0.4*random.random(), 0.6+0.4*random.random())
-    canvas.drawRect(0,0,plotWidth,plotHeight, edgeColor=bgColor, fillColor=bgColor)
-
-    for i in range(30):
-        randomColor = pid.Color(0.6+0.4*random.random(), 0.6+0.4*random.random(), 0.6+0.4*random.random())
-        scaleFont=pid.Font(ttf="cour",size=random.choice(range(20, 50)))
-        canvas.drawString(random.choice('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'),
-                int(random.random()*plotWidth), int(random.random()*plotHeight), font=scaleFont,
-                color=randomColor, angle=random.choice(range(-45, 50)))
-
-    step = (plotWidth-20)/len(text)
-    startX = 20
-    for item in text:
-        randomColor = pid.Color(0.6*random.random(),0.6*random.random(), 0.6*random.random())
-        scaleFont=pid.Font(ttf="verdana",size=random.choice(range(50, 60)),bold=1)
-        canvas.drawString(item, startX, plotHeight/2-10, font=scaleFont,
-                color=randomColor, angle=random.choice(range(-45, 50)))
-        startX += step
-
 # parameter: data is either object returned by reaper permutation function (called by MarkerRegressionPage.py)
 # or the first object returned by direct (pair-scan) permu function (called by DirectPlotPage.py)
 def plotBar(canvas, data, barColor=pid.blue, axesColor=pid.black, labelColor=pid.black, XLabel=None, YLabel=None, title=None, offset= (60, 20, 40, 40), zoom = 1):
@@ -561,542 +204,6 @@ def plotBar(canvas, data, barColor=pid.blue, axesColor=pid.black, labelColor=pid
        canvas.drawString(title,xLeftOffset+(plotWidth-canvas.stringWidth(title,font=labelFont))/2.0,
                20,font=labelFont,color=labelColor)
 
-def plotBarText(canvas, data, label, variance=None, barColor=pid.blue, axesColor=pid.black, labelColor=pid.black, XLabel=None, YLabel=None, title=None, sLabel = None, offset= (80, 20, 40, 100), barSpace = 2, zoom = 1):
-    xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
-    plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
-    plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
-    if plotHeight<=0 or plotWidth<=0:
-       return
-
-    NNN = len(data)
-    if NNN < 2 or NNN != len(label):
-       return
-    if variance and len(variance)!=NNN:
-       variance = []
-
-    Y2 = data[:]
-    if variance:
-       for i in range(NNN):
-           if variance[i]:
-               Y2 += [data[i]-variance[i]]
-
-    #Y axis
-    YLow, YTop, stepY = detScale(min(Y2), max(Y2))
-    YScale = plotHeight/(YTop - YLow)
-
-    if YLow < 0  and  YTop > 0:
-       drawZero = 1
-    else:
-       drawZero = 0
-
-    #X axis
-    X = range(NNN)
-    Xll= 0
-    Xur= NNN-1
-
-
-    if drawZero:
-       YZero = yTopOffset+plotHeight-YScale*(0-YLow)
-       canvas.drawLine(xLeftOffset, YZero, xLeftOffset+plotWidth, YZero)
-    else:
-       YZero = yTopOffset+plotHeight
-    #draw data
-    spaceWidth = barSpace
-    if spaceWidth < 1:
-       spaceWidth = 1
-    barWidth = int((plotWidth - (NNN-1.0)*spaceWidth)/NNN)
-
-    xc= xLeftOffset
-    scaleFont=pid.Font(ttf="verdana",size=11,bold=0)
-    for i in range(NNN):
-       yc = yTopOffset+plotHeight-(data[i]-YLow)*YScale
-       canvas.drawRect(xc,YZero,xc+barWidth-1, yc, edgeColor=barColor,fillColor=barColor)
-       if variance and variance[i]:
-           varlen = variance[i]*YScale
-           if yc-varlen < yTopOffset:
-               topYd = yTopOffset
-           else:
-               topYd = yc-varlen
-               canvas.drawLine(xc+barWidth/2-2,yc-varlen,xc+barWidth/2+2,yc-varlen,color=pid.red)
-           canvas.drawLine(xc+barWidth/2,yc+varlen,xc+barWidth/2,topYd,color=pid.red)
-           canvas.drawLine(xc+barWidth/2-2,yc+varlen,xc+barWidth/2+2,yc+varlen,color=pid.red)
-       strX = label[i]
-       canvas.drawString(strX,xc+barWidth/2.0+2,yTopOffset+plotHeight+2+canvas.stringWidth(strX,font=scaleFont),font=scaleFont,angle=90)
-       xc += barWidth + spaceWidth
-
-    #draw drawing region
-    canvas.drawRect(xLeftOffset, yTopOffset, xLeftOffset+plotWidth, yTopOffset+plotHeight)
-
-    #draw Y scale
-    scaleFont=pid.Font(ttf="cour",size=16,bold=1)
-    y=YLow
-    for i in range(stepY+1):
-       yc=yTopOffset+plotHeight-(y-YLow)*YScale
-       canvas.drawLine(xLeftOffset,yc,xLeftOffset-5,yc, color=axesColor)
-       strY = cformat(d=y, rank=0)
-       canvas.drawString(strY,xLeftOffset-canvas.stringWidth(strY,font=scaleFont)-6,yc+5,font=scaleFont)
-       y+= (YTop - YLow)/stepY
-
-    #draw label
-    labelFont=pid.Font(ttf="verdana",size=17,bold=0)
-    if XLabel:
-       canvas.drawString(XLabel,xLeftOffset+(plotWidth-canvas.stringWidth(XLabel,font=labelFont))/2.0,yTopOffset+plotHeight+65,font=labelFont,color=labelColor)
-
-    if YLabel:
-       canvas.drawString(YLabel,xLeftOffset-50, yTopOffset+plotHeight-(plotHeight-canvas.stringWidth(YLabel,font=labelFont))/2.0,font=labelFont,color=labelColor,angle=90)
-
-    labelFont=pid.Font(ttf="verdana",size=18,bold=0)
-    if title:
-       canvas.drawString(title,xLeftOffset,yTopOffset-15,font=labelFont,color=labelColor)
-
-    return
-
-#def plotXY(canvas, dataX, dataY, rank=0, dataLabel=[], plotColor = pid.black, axesColor=pid.black, labelColor=pid.black, lineSize="thin", lineColor=pid.grey, idFont="arial", idColor=pid.blue, idSize="14", symbolColor=pid.black, symbolType="circle", filled="yes", symbolSize="tiny", XLabel=None, YLabel=None, title=None, fitcurve=None, connectdot=1, displayR=None, loadingPlot = 0, offset= (80, 20, 40, 60), zoom = 1, specialCases=[], showLabel = 1, bufferSpace = 15):
-#    'displayR : correlation scatter plot, loadings : loading plot'
-#
-#    dataXRanked, dataYRanked = webqtlUtil.calRank(dataX, dataY, len(dataX))
-#
-#    #get ID font size
-#    idFontSize = int(idSize)
-#
-#    #If filled is yes, set fill color
-#    if filled == "yes":
-#        fillColor = symbolColor
-#    else:
-#        fillColor = None
-#
-#    if symbolSize == "large":
-#        sizeModifier = 7
-#        fontModifier = 12
-#    elif symbolSize == "medium":
-#        sizeModifier = 5
-#        fontModifier = 8
-#    elif symbolSize == "small":
-#        sizeModifier = 3
-#        fontModifier = 3
-#    else:
-#        sizeModifier = 1
-#        fontModifier = -1
-#
-#    if rank == 0:    # Pearson correlation
-#        bufferSpace = 0
-#        dataXPrimary = dataX
-#        dataYPrimary = dataY
-#        dataXAlt = dataXRanked    #Values used just for printing the other corr type to the graph image
-#        dataYAlt = dataYRanked    #Values used just for printing the other corr type to the graph image
-#    else:    # Spearman correlation: Switching Ranked and Unranked X and Y values
-#        dataXPrimary = dataXRanked
-#        dataYPrimary = dataYRanked
-#        dataXAlt = dataX    #Values used just for printing the other corr type to the graph image
-#        dataYAlt = dataY    #Values used just for printing the other corr type to the graph image
-#
-#    xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
-#    plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
-#    plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
-#    if plotHeight<=0 or plotWidth<=0:
-#        return
-#    if len(dataXPrimary) < 1 or  len(dataXPrimary) != len(dataYPrimary) or (dataLabel and len(dataXPrimary) != len(dataLabel)):
-#        return
-#
-#    max_X=max(dataXPrimary)
-#    min_X=min(dataXPrimary)
-#    max_Y=max(dataYPrimary)
-#    min_Y=min(dataYPrimary)
-#
-#    #for some reason I forgot why I need to do this
-#    if loadingPlot:
-#        min_X = min(-0.1,min_X)
-#        max_X = max(0.1,max_X)
-#        min_Y = min(-0.1,min_Y)
-#        max_Y = max(0.1,max_Y)
-#
-#    xLow, xTop, stepX=detScale(min_X,max_X)
-#    yLow, yTop, stepY=detScale(min_Y,max_Y)
-#    xScale = plotWidth/(xTop-xLow)
-#    yScale = plotHeight/(yTop-yLow)
-#
-#    #draw drawing region
-#    canvas.drawRect(xLeftOffset-bufferSpace, yTopOffset, xLeftOffset+plotWidth, yTopOffset+plotHeight+bufferSpace)
-#    canvas.drawRect(xLeftOffset-bufferSpace+1, yTopOffset, xLeftOffset+plotWidth, yTopOffset+plotHeight+bufferSpace-1)
-#
-#    #calculate data points
-#    data = map(lambda X, Y: (X, Y), dataXPrimary, dataYPrimary)
-#    xCoord = map(lambda X, Y: ((X-xLow)*xScale + xLeftOffset, yTopOffset+plotHeight-(Y-yLow)*yScale), dataXPrimary, dataYPrimary)
-#
-#    labelFont=pid.Font(ttf=idFont,size=idFontSize,bold=0)
-#
-#    if loadingPlot:
-#        xZero = -xLow*xScale+xLeftOffset
-#        yZero = yTopOffset+plotHeight+yLow*yScale
-#        for point in xCoord:
-#            canvas.drawLine(xZero,yZero,point[0],point[1],color=pid.red)
-#    else:
-#        if connectdot:
-#            canvas.drawPolygon(xCoord,edgeColor=plotColor,closed=0)
-#        else:
-#            pass
-#
-#    symbolFont = pid.Font(ttf="fnt_bs", size=12+fontModifier,bold=0)
-#
-#    for i, item in enumerate(xCoord):
-#        if dataLabel and dataLabel[i] in specialCases:
-#            canvas.drawRect(item[0]-3, item[1]-3, item[0]+3, item[1]+3, edgeColor=pid.green)
-#            #canvas.drawCross(item[0],item[1],color=pid.blue,size=5)
-#        else:
-#            if symbolType == "vertRect":
-#                canvas.drawRect(x1=item[0]-sizeModifier+2,y1=item[1]-sizeModifier-2, x2=item[0]+sizeModifier-1,y2=item[1]+sizeModifier+2, edgeColor=symbolColor, edgeWidth=1, fillColor=fillColor)
-#            elif (symbolType == "circle" and filled != "yes"):
-#                canvas.drawString(":", item[0]-canvas.stringWidth(":",font=symbolFont)/2+1,item[1]+2,color=symbolColor, font=symbolFont)
-#            elif (symbolType == "circle" and filled == "yes"):
-#                canvas.drawString("5", item[0]-canvas.stringWidth("5",font=symbolFont)/2+1,item[1]+2,color=symbolColor, font=symbolFont)
-#            elif symbolType == "horiRect":
-#                canvas.drawRect(x1=item[0]-sizeModifier-1,y1=item[1]-sizeModifier+3, x2=item[0]+sizeModifier+3,y2=item[1]+sizeModifier-2, edgeColor=symbolColor, edgeWidth=1, fillColor=fillColor)
-#            elif (symbolType == "square"):
-#                canvas.drawRect(x1=item[0]-sizeModifier+1,y1=item[1]-sizeModifier-4, x2=item[0]+sizeModifier+2,y2=item[1]+sizeModifier-3, edgeColor=symbolColor, edgeWidth=1, fillColor=fillColor)
-#            elif (symbolType == "diamond" and filled != "yes"):
-#                canvas.drawString(",", item[0]-canvas.stringWidth(",",font=symbolFont)/2+2, item[1]+6, font=symbolFont, color=symbolColor)
-#            elif (symbolType == "diamond" and filled == "yes"):
-#                canvas.drawString("D", item[0]-canvas.stringWidth("D",font=symbolFont)/2+2, item[1]+6, font=symbolFont, color=symbolColor)
-#            elif symbolType == "4-star":
-#                canvas.drawString("l", item[0]-canvas.stringWidth("l",font=symbolFont)/2+1, item[1]+3, font=symbolFont, color=symbolColor)
-#            elif symbolType == "3-star":
-#                canvas.drawString("k", item[0]-canvas.stringWidth("k",font=symbolFont)/2+1, item[1]+3, font=symbolFont, color=symbolColor)
-#            else:
-#                canvas.drawCross(item[0],item[1]-2,color=symbolColor, size=sizeModifier+2)
-#
-#        if showLabel and dataLabel:
-#            if (symbolType == "vertRect" or symbolType == "diamond"):
-#                labelGap = 15
-#            elif (symbolType == "4-star" or symbolType == "3-star"):
-#                labelGap = 12
-#            else:
-#                labelGap = 11
-#            canvas.drawString(dataLabel[i], item[0]- canvas.stringWidth(dataLabel[i],
-#                    font=labelFont)/2 + 1, item[1]+(labelGap+sizeModifier+(idFontSize-12)), font=labelFont, color=idColor)
-#
-#    #draw scale
-#    scaleFont=pid.Font(ttf="cour",size=16,bold=1)
-#
-#
-#    x=xLow
-#    for i in range(stepX+1):
-#        xc=xLeftOffset+(x-xLow)*xScale
-#        if ((x == 0) & (rank == 1)):
-#            pass
-#        else:
-#            canvas.drawLine(xc,yTopOffset+plotHeight + bufferSpace,xc,yTopOffset+plotHeight+5 + bufferSpace, color=axesColor)
-#        strX = cformat(d=x, rank=rank)
-#        if ((strX == "0") & (rank == 1)):
-#            pass
-#        else:
-#            canvas.drawString(strX,xc-canvas.stringWidth(strX,font=scaleFont)/2,yTopOffset+plotHeight+20 + bufferSpace,font=scaleFont)
-#        x+= (xTop - xLow)/stepX
-#
-#    y=yLow
-#    for i in range(stepY+1):
-#        yc=yTopOffset+plotHeight-(y-yLow)*yScale
-#        if ((y == 0) & (rank == 1)):
-#            pass
-#        else:
-#            canvas.drawLine(xLeftOffset - bufferSpace,yc,xLeftOffset-5 - bufferSpace,yc, color=axesColor)
-#        strY = cformat(d=y, rank=rank)
-#        if ((strY == "0") & (rank == 1)):
-#            pass
-#        else:
-#            canvas.drawString(strY,xLeftOffset-canvas.stringWidth(strY,font=scaleFont)- 10 - bufferSpace,yc+4,font=scaleFont)
-#        y+= (yTop - yLow)/stepY
-#
-#    #draw label
-#
-#    labelFont=pid.Font(ttf="verdana",size=canvas.size[0]/45,bold=0)
-#    titleFont=pid.Font(ttf="verdana",size=canvas.size[0]/40,bold=0)
-#
-#    if (rank == 1 and not title):
-#        canvas.drawString("Spearman Rank Correlation", xLeftOffset-canvas.size[0]*.025+(plotWidth-canvas.stringWidth("Spearman Rank Correlation",font=titleFont))/2.0,
-#                                          25,font=titleFont,color=labelColor)
-#    elif (rank == 0 and not title):
-#        canvas.drawString("Pearson Correlation", xLeftOffset-canvas.size[0]*.025+(plotWidth-canvas.stringWidth("Pearson Correlation",font=titleFont))/2.0,
-#                                          25,font=titleFont,color=labelColor)
-#
-#    if XLabel:
-#        canvas.drawString(XLabel,xLeftOffset+(plotWidth-canvas.stringWidth(XLabel,font=labelFont))/2.0,
-#                yTopOffset+plotHeight+yBottomOffset-25,font=labelFont,color=labelColor)
-#
-#    if YLabel:
-#        canvas.drawString(YLabel, xLeftOffset-65, yTopOffset+plotHeight- (plotHeight-canvas.stringWidth(YLabel,font=labelFont))/2.0,
-#                font=labelFont,color=labelColor,angle=90)
-#
-#    labelFont=pid.Font(ttf="verdana",size=20,bold=0)
-#    if title:
-#        canvas.drawString(title,xLeftOffset+(plotWidth-canvas.stringWidth(title,font=labelFont))/2.0,
-#                20,font=labelFont,color=labelColor)
-#
-#    if fitcurve:
-#        import sys
-#        sys.argv = [ "mod_python" ]
-#        #from numarray import linear_algebra as la
-#        #from numarray import ones, array, dot, swapaxes
-#        fitYY = array(dataYPrimary)
-#        fitXX = array([ones(len(dataXPrimary)),dataXPrimary])
-#        AA = dot(fitXX,swapaxes(fitXX,0,1))
-#        BB = dot(fitXX,fitYY)
-#        bb = la.linear_least_squares(AA,BB)[0]
-#
-#        xc1 = xLeftOffset
-#        yc1 = yTopOffset+plotHeight-(bb[0]+bb[1]*xLow-yLow)*yScale
-#        if yc1 > yTopOffset+plotHeight:
-#            yc1 = yTopOffset+plotHeight
-#            xc1 = (yLow-bb[0])/bb[1]
-#            xc1=(xc1-xLow)*xScale+xLeftOffset
-#        elif yc1 < yTopOffset:
-#            yc1 = yTopOffset
-#            xc1 = (yTop-bb[0])/bb[1]
-#            xc1=(xc1-xLow)*xScale+xLeftOffset
-#        else:
-#            pass
-#
-#        xc2 = xLeftOffset + plotWidth
-#        yc2 = yTopOffset+plotHeight-(bb[0]+bb[1]*xTop-yLow)*yScale
-#        if yc2 > yTopOffset+plotHeight:
-#            yc2 = yTopOffset+plotHeight
-#            xc2 = (yLow-bb[0])/bb[1]
-#            xc2=(xc2-xLow)*xScale+xLeftOffset
-#        elif yc2 < yTopOffset:
-#            yc2 = yTopOffset
-#            xc2 = (yTop-bb[0])/bb[1]
-#            xc2=(xc2-xLow)*xScale+xLeftOffset
-#        else:
-#            pass
-#
-#        canvas.drawLine(xc1 - bufferSpace,yc1 + bufferSpace,xc2,yc2,color=lineColor)
-#        if lineSize == "medium":
-#            canvas.drawLine(xc1 - bufferSpace,yc1 + bufferSpace+1,xc2,yc2+1,color=lineColor)
-#        if lineSize == "thick":
-#            canvas.drawLine(xc1 - bufferSpace,yc1 + bufferSpace+1,xc2,yc2+1,color=lineColor)
-#            canvas.drawLine(xc1 - bufferSpace,yc1 + bufferSpace-1,xc2,yc2-1,color=lineColor)
-#
-#
-#    if displayR:
-#        labelFont=pid.Font(ttf="trebuc",size=canvas.size[0]/60,bold=0)
-#        NNN = len(dataX)
-#        corr = webqtlUtil.calCorrelation(dataXPrimary,dataYPrimary,NNN)[0]
-#
-#        if NNN < 3:
-#            corrPValue = 1.0
-#        else:
-#            if abs(corr) >= 1.0:
-#                corrPValue = 0.0
-#            else:
-#                ZValue = 0.5*log((1.0+corr)/(1.0-corr))
-#                ZValue = ZValue*sqrt(NNN-3)
-#                corrPValue = 2.0*(1.0 - reaper.normp(abs(ZValue)))
-#
-#        NStr = "N = %d" % NNN
-#        strLenN = canvas.stringWidth(NStr,font=labelFont)
-#
-#        if rank == 1:
-#            if corrPValue < 0.0000000000000001:
-#                corrStr = "Rho = %1.3f P < 1.00 E-16" % (corr)
-#            else:
-#                corrStr = "Rho = %1.3f P = %3.2E" % (corr, corrPValue)
-#        else:
-#            if corrPValue < 0.0000000000000001:
-#                corrStr = "r = %1.3f P < 1.00 E-16" % (corr)
-#            else:
-#                corrStr = "r = %1.3f P = %3.2E" % (corr, corrPValue)
-#        strLen = canvas.stringWidth(corrStr,font=labelFont)
-#
-#        canvas.drawString(NStr,xLeftOffset,yTopOffset-10,font=labelFont,color=labelColor)
-#        canvas.drawString(corrStr,xLeftOffset+plotWidth-strLen,yTopOffset-10,font=labelFont,color=labelColor)
-#
-#    return xCoord
-
-def plotXYSVG(drawSpace, dataX, dataY, rank=0, dataLabel=[], plotColor = "black", axesColor="black", labelColor="black", symbolColor="red", XLabel=None, YLabel=None, title=None, fitcurve=None, connectdot=1, displayR=None, loadingPlot = 0, offset= (80, 20, 40, 60), zoom = 1, specialCases=[], showLabel = 1):
-    'displayR : correlation scatter plot, loadings : loading plot'
-
-    dataXRanked, dataYRanked = webqtlUtil.calRank(dataX, dataY, len(dataX))
-
-    # Switching Ranked and Unranked X and Y values if a Spearman Rank Correlation
-    if rank == 0:
-        dataXPrimary = dataX
-        dataYPrimary = dataY
-        dataXAlt = dataXRanked
-        dataYAlt = dataYRanked
-
-    else:
-        dataXPrimary = dataXRanked
-        dataYPrimary = dataYRanked
-        dataXAlt = dataX
-        dataYAlt = dataY
-
-
-
-    xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
-    plotWidth = drawSpace.attributes['width'] - xLeftOffset - xRightOffset
-    plotHeight = drawSpace.attributes['height'] - yTopOffset - yBottomOffset
-    if plotHeight<=0 or plotWidth<=0:
-        return
-    if len(dataXPrimary) < 1 or  len(dataXPrimary) != len(dataYPrimary) or (dataLabel and len(dataXPrimary) != len(dataLabel)):
-        return
-
-    max_X=max(dataXPrimary)
-    min_X=min(dataXPrimary)
-    max_Y=max(dataYPrimary)
-    min_Y=min(dataYPrimary)
-
-    #for some reason I forgot why I need to do this
-    if loadingPlot:
-        min_X = min(-0.1,min_X)
-        max_X = max(0.1,max_X)
-        min_Y = min(-0.1,min_Y)
-        max_Y = max(0.1,max_Y)
-
-    xLow, xTop, stepX=detScale(min_X,max_X)
-    yLow, yTop, stepY=detScale(min_Y,max_Y)
-    xScale = plotWidth/(xTop-xLow)
-    yScale = plotHeight/(yTop-yLow)
-
-    #draw drawing region
-    r = svg.rect(xLeftOffset, yTopOffset, plotWidth,  plotHeight, 'none', axesColor, 1)
-    drawSpace.addElement(r)
-
-    #calculate data points
-    data = map(lambda X, Y: (X, Y), dataXPrimary, dataYPrimary)
-    xCoord = map(lambda X, Y: ((X-xLow)*xScale + xLeftOffset, yTopOffset+plotHeight-(Y-yLow)*yScale), dataXPrimary, dataYPrimary)
-    labelFontF = "verdana"
-    labelFontS = 11
-
-    if loadingPlot:
-        xZero = -xLow*xScale+xLeftOffset
-        yZero = yTopOffset+plotHeight+yLow*yScale
-        for point in xCoord:
-            drawSpace.addElement(svg.line(xZero,yZero,point[0],point[1], "red", 1))
-    else:
-        if connectdot:
-            pass
-            #drawSpace.drawPolygon(xCoord,edgeColor=plotColor,closed=0)
-        else:
-            pass
-
-    for i, item in enumerate(xCoord):
-        if dataLabel and dataLabel[i] in specialCases:
-            drawSpace.addElement(svg.rect(item[0]-3, item[1]-3, 6, 6, "none", "green", 0.5))
-            #drawSpace.drawCross(item[0],item[1],color=pid.blue,size=5)
-        else:
-            drawSpace.addElement(svg.line(item[0],item[1]+5,item[0],item[1]-5,symbolColor,1))
-            drawSpace.addElement(svg.line(item[0]+5,item[1],item[0]-5,item[1],symbolColor,1))
-        if showLabel and dataLabel:
-            pass
-            drawSpace.addElement(svg.text(item[0], item[1]+14, dataLabel[i], labelFontS,
-                    labelFontF, text_anchor="middle", style="stroke:blue;stroke-width:0.5;"))
-            #canvas.drawString(, item[0]- canvas.stringWidth(dataLabel[i],
-            #       font=labelFont)/2, item[1]+14, font=labelFont, color=pid.blue)
-
-    #draw scale
-    #scaleFont=pid.Font(ttf="cour",size=14,bold=1)
-    x=xLow
-    for i in range(stepX+1):
-        xc=xLeftOffset+(x-xLow)*xScale
-        drawSpace.addElement(svg.line(xc,yTopOffset+plotHeight,xc,yTopOffset+plotHeight+5, axesColor, 1))
-        strX = cformat(d=x, rank=rank)
-        drawSpace.addElement(svg.text(xc,yTopOffset+plotHeight+20,strX,13, "courier", text_anchor="middle"))
-        x+= (xTop - xLow)/stepX
-
-    y=yLow
-    for i in range(stepY+1):
-        yc=yTopOffset+plotHeight-(y-yLow)*yScale
-        drawSpace.addElement(svg.line(xLeftOffset,yc,xLeftOffset-5,yc, axesColor, 1))
-        strY = cformat(d=y, rank=rank)
-        drawSpace.addElement(svg.text(xLeftOffset-10,yc+5,strY,13, "courier", text_anchor="end"))
-        y+= (yTop - yLow)/stepY
-
-    #draw label
-    labelFontF = "verdana"
-    labelFontS = 17
-    if XLabel:
-        drawSpace.addElement(svg.text(xLeftOffset+plotWidth/2.0,
-                yTopOffset+plotHeight+yBottomOffset-10,XLabel,
-                labelFontS, labelFontF, text_anchor="middle"))
-
-    if YLabel:
-        drawSpace.addElement(svg.text(xLeftOffset-50,
-                 yTopOffset+plotHeight/2,YLabel,
-                labelFontS, labelFontF, text_anchor="middle", style="writing-mode:tb-rl", transform="rotate(270 %d %d)" % (xLeftOffset-50,  yTopOffset+plotHeight/2)))
-        #drawSpace.drawString(YLabel, xLeftOffset-50, yTopOffset+plotHeight- (plotHeight-drawSpace.stringWidth(YLabel,font=labelFont))/2.0,
-        #       font=labelFont,color=labelColor,angle=90)
-
-
-    if fitcurve:
-        sys.argv = [ "mod_python" ]
-        #from numarray import linear_algebra as la
-        #from numarray import ones, array, dot, swapaxes
-        fitYY = array(dataYPrimary)
-        fitXX = array([ones(len(dataXPrimary)),dataXPrimary])
-        AA = dot(fitXX,swapaxes(fitXX,0,1))
-        BB = dot(fitXX,fitYY)
-        bb = la.linear_least_squares(AA,BB)[0]
-
-        xc1 = xLeftOffset
-        yc1 = yTopOffset+plotHeight-(bb[0]+bb[1]*xLow-yLow)*yScale
-        if yc1 > yTopOffset+plotHeight:
-            yc1 = yTopOffset+plotHeight
-            xc1 = (yLow-bb[0])/bb[1]
-            xc1=(xc1-xLow)*xScale+xLeftOffset
-        elif yc1 < yTopOffset:
-            yc1 = yTopOffset
-            xc1 = (yTop-bb[0])/bb[1]
-            xc1=(xc1-xLow)*xScale+xLeftOffset
-        else:
-            pass
-
-        xc2 = xLeftOffset + plotWidth
-        yc2 = yTopOffset+plotHeight-(bb[0]+bb[1]*xTop-yLow)*yScale
-        if yc2 > yTopOffset+plotHeight:
-            yc2 = yTopOffset+plotHeight
-            xc2 = (yLow-bb[0])/bb[1]
-            xc2=(xc2-xLow)*xScale+xLeftOffset
-        elif yc2 < yTopOffset:
-            yc2 = yTopOffset
-            xc2 = (yTop-bb[0])/bb[1]
-            xc2=(xc2-xLow)*xScale+xLeftOffset
-        else:
-            pass
-
-        drawSpace.addElement(svg.line(xc1,yc1,xc2,yc2,"green", 1))
-
-    if displayR:
-        labelFontF = "trebuc"
-        labelFontS = 14
-        NNN = len(dataX)
-
-        corr = webqtlUtil.calCorrelation(dataXPrimary,dataYPrimary,NNN)[0]
-
-        if NNN < 3:
-            corrPValue = 1.0
-        else:
-            if abs(corr) >= 1.0:
-                corrPValue = 0.0
-            else:
-                ZValue = 0.5*log((1.0+corr)/(1.0-corr))
-                ZValue = ZValue*sqrt(NNN-3)
-                corrPValue = 2.0*(1.0 - reaper.normp(abs(ZValue)))
-
-        NStr = "N of Cases=%d" % NNN
-
-        if rank == 1:
-            corrStr = "Spearman's r=%1.3f P=%3.2E" % (corr, corrPValue)
-        else:
-            corrStr = "Pearson's r=%1.3f P=%3.2E" % (corr, corrPValue)
-
-        drawSpace.addElement(svg.text(xLeftOffset,yTopOffset-10,NStr,
-                labelFontS, labelFontF, text_anchor="start"))
-        drawSpace.addElement(svg.text(xLeftOffset+plotWidth,yTopOffset-25,corrStr,
-                labelFontS, labelFontF, text_anchor="end"))
-    """
-    """
-    return
-
-
 # This function determines the scale of the plot
 def detScaleOld(min,max):
     if min>=max:
@@ -1114,7 +221,7 @@ def detScaleOld(min,max):
         high=c*ceil(max/c)
         return [low,high,round((high-low)/c)]
 
-def detScale(min=0,max=0,bufferSpace=3):
+def detScale(min=0,max=0):
 
     if min>=max:
         return None
@@ -1151,57 +258,9 @@ def detScale(min=0,max=0,bufferSpace=3):
 
         return [low,high,n]
 
-
-
-def colorSpectrumOld(n):
-    if n == 1:
-        return [pid.Color(1,0,0)]
-    elif n == 2:
-        return [pid.Color(1,0,0),pid.Color(0,0,1)]
-    elif n == 3:
-        return [pid.Color(1,0,0),pid.Color(0,1,0),pid.Color(0,0,1)]
-    else:
-        step = 2.0/(n-1)
-        red = 1.0
-        green = 0.0
-        blue = 0.0
-        colors = [pid.Color(red,green,blue)]
-        i = 1
-        greenpeak = 0
-        while i < n:
-            if red >= step:
-                red -= step
-                green += step
-                if green >= 1.0:
-                    greenpeak = 1
-                    blue += green -1.0
-                    green = 1.0
-            else:
-                red = 0.0
-                if greenpeak:
-                    green -= step
-                    blue += step
-                else:
-                    green += step
-                if green >= 1.0:
-                    greenpeak = 1
-                    blue += green -1.0
-                    green = 2.0 -green
-                elif green < 0.0:
-                    green = 0.0
-                else:
-                    pass
-            colors.append(pid.Color(red,green,blue))
-            i += 1
-        return colors
-
-
-
-
 def bluefunc(x):
     return 1.0 / (1.0 + exp(-10*(x-0.6)))
 
-
 def redfunc(x):
     return 1.0 / (1.0 + exp(10*(x-0.5)))
 
@@ -1230,52 +289,10 @@ def colorSpectrum(n=100):
     out2.append(out[-1])
     return out2
 
-
-def colorSpectrumSVG(n=100):
-    multiple = 10
-    if n == 1:
-        return ["rgb(255,0,0)"]
-    elif n == 2:
-        return ["rgb(255,0,0)","rgb(0,0,255)"]
-    elif n == 3:
-        return ["rgb(255,0,0)","rgb(0,255,0)","rgb(0,0,255)"]
-    N = n*multiple
-    out = [None]*N;
-    for i in range(N):
-        x = float(i)/N
-        out[i] = "rgb(%d, %d, %d)" % (redfunc(x)*255, greenfunc(x)*255, bluefunc(x)*255);
-    out2 = [out[0]]
-    step = N/float(n-1)
-    j = 0
-    for i in range(n-2):
-        j += step
-        out2.append(out[int(j)])
-    out2.append(out[-1])
-    return out2
-
-
-def BWSpectrum(n=100):
-    multiple = 10
-    if n == 1:
-        return [pid.Color(0,0,0)]
-    elif n == 2:
-        return [pid.Color(0,0,0),pid.Color(1,1,1)]
-    elif n == 3:
-        return [pid.Color(0,0,0),pid.Color(0.5,0.5,0.5),pid.Color(1,1,1)]
-
-    step = 1.0/n
-    x = 0.0
-    out = []
-    for i in range(n):
-        out.append(pid.Color(x,x,x));
-        x += step
-    return out
-
-
 def _test():
     import doctest
     doctest.testmod()
 
 
 if __name__=="__main__":
-    _test()
+    _test()
\ No newline at end of file