diff options
Diffstat (limited to 'web/webqtl/networkGraph/networkGraphUtils.py')
| -rw-r--r-- | web/webqtl/networkGraph/networkGraphUtils.py | 750 |
1 files changed, 750 insertions, 0 deletions
diff --git a/web/webqtl/networkGraph/networkGraphUtils.py b/web/webqtl/networkGraph/networkGraphUtils.py new file mode 100644 index 00000000..fd0e7484 --- /dev/null +++ b/web/webqtl/networkGraph/networkGraphUtils.py @@ -0,0 +1,750 @@ +# Copyright (C) University of Tennessee Health Science Center, Memphis, TN. +# +# This program is free software: you can redistribute it and/or modify it +# under the terms of the GNU Affero General Public License +# as published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the GNU Affero General Public License for more details. +# +# This program is available from Source Forge: at GeneNetwork Project +# (sourceforge.net/projects/genenetwork/). +# +# Contact Drs. Robert W. Williams and Xiaodong Zhou (2010) +# at rwilliams@uthsc.edu and xzhou15@uthsc.edu +# +# +# +# This module is used by GeneNetwork project (www.genenetwork.org) +# +# Created by GeneNetwork Core Team 2010/08/10 +# +# Last updated by GeneNetwork Core Team 2010/10/20 + +# graphviz: +# a library for sending trait data to the graphviz utilities to get +# graphed + +# ParamDict: a dictionary of strings that map to strings where the keys are +# valid parameters and the values are validated versions of those parameters +# +# The list below also works for visualize.py; different parameters apply to different +# functions in the pipeline. See visualize.py for more details. +# +# parameters: +# filename: an input file with comma-delimited data to visualize +# kValue: +# how to filter the edges; edges with correlation coefficents in +# [-k, k] are not drawn +# whichValue: which of the two correlation coefficents are used; +# 0 means the top half (pearson) and +# 1 means the bottom half (spearman) +# width: the width of the graph in inches +# height: the height of the graph in inches +# --scale: an amount to multiply the length factors by to space out the nodes +# spline: whether to use splines instead of straight lines to draw graphs +# tune: whether to automatically pick intelligent default values for +# kValue and spline based on the number of edges in the input data +# whichVersion: whether to display the graph zoomed or fullscreen +# 0 means zoom +# 1 means fullscreen +# printIslands: whether to display nodes with no visible edges +# + +# DataMatrix: a one-dimensional array of DataPoints in sorted order by i first + + + +import copy +import os +#import os.path +import math +import string + +from base import webqtlConfig +from utility import webqtlUtil +#import trait +from nGraphException import nGraphException +from ProcessedPoint import ProcessedPoint + + +# processDataMatrix: DataMatrix -> ParamDict -> void +# this is the second part after filterDataMatrix +# To process the set of points in a DataMatrix as follows +# 1) choose an appropriate color for the data point +# 2) filter those between k values +# 3) to use an r-to-Z transform to spread out the correlation +# values from [-1,1] to (-inf, inf) +# 4) to invert the values so that higher correlations result in +# shorter edges +# +# Note: this function modifies the matrix in-place. My functional +# programming instincts tell me that this is a bad idea. +def processDataMatrix(matrix, p): + for pt2 in matrix: + # filter using k + if (-p["kValue"] <= pt2.value) and (pt2.value <= p["kValue"]): + pt2.value = 0.00 + + # Lei Yan + # 05/28/2009 + # fix color + + # pick a color + if pt2.value >= 0.7: + pt2.color = p["cL6Name"] + pt2.style = p["L6style"] + elif pt2.value >= 0.5: + pt2.color = p["cL5Name"] + pt2.style = p["L5style"] + elif pt2.value >= 0.0: + pt2.color = p["cL4Name"] + pt2.style = p["L4style"] + elif pt2.value >= -0.5: + pt2.color = p["cL3Name"] + pt2.style = p["L3style"] + elif pt2.value >= -0.7: + pt2.color = p["cL2Name"] + pt2.style = p["L2style"] + else: + pt2.color = p["cL1Name"] + pt2.style = p["L1style"] + + # r to Z transform to generate the length + # 0 gets transformed to infinity, which we can't + # represent here, and 1 gets transformed to 0 + if p["lock"] == "no": + if -0.01 < pt2.value and pt2.value < 0.01: + pt2.length = 1000 + elif pt2.value > 0.99 or pt2.value < -0.99: + pt2.length = 0 + else: + pt2.length = pt2.value + pt2.length = 0.5 * math.log((1 + pt2.length)/(1 - pt2.length)) + + # invert so higher correlations mean closer edges + #pt2.length = abs(p["scale"] * 1/pt2.length) + pt2.length = abs(1/pt2.length) + else: + pt2.length = 2 + + +# tuneParamDict: ParamDict -> Int -> Int -> ParamDict +# to adjust the parameter dictionary for a first-time run +# so that the graphing doesn't take so long, especially since +# small parameter changes can make a big performance difference +# note: you can pass this function an empty dictionary and +# get back a good set of default parameters for your +# particular graph +def tuneParamDict(p, nodes, edges): + newp = copy.deepcopy(p) + + if nodes > 50: + newp["splines"] = "no" + else: + newp["splines"] = "yes" + + if edges > 1000: + newp["printIslands"] = 0 + else: + newp["printIslands"] = 1 + + if edges > 1000: + newp["kValue"] = 0.8 + elif edges > 500: + newp["kValue"] = 0.7 + elif edges > 250: + newp["kValue"] = 0.6 + + if nodes > 50: + # there's no magic here; this formula + # just seems to work + dim = 3*math.sqrt(nodes) + newp["width"] = round(dim,2) + newp["height"] = round(dim,2) + + # the two values below shouldn't change + # newp["scale"] = round(dim/10.0,2) + # newp["fontsize"] = round(14*newp["scale"],0) + + else: + newp["width"] = 40.0 + newp["height"] = 40.0 + + return newp + +# fixLabel : string -> string +def fixLabel(lbl): + """ + To split a label with newlines so it looks a bit better + Note: we send the graphing program literal '\n' strings and + it converts these into newlines + """ + lblparts = lbl.split(" ") + newlbl = "" + i = 0 + for part in lblparts: + if 10*(i+1) < len(newlbl): + i += 1 + newlbl = newlbl + r"\n" + part + else: + newlbl = newlbl + " " + part + return newlbl + #return "\N" + +def writeGraphFile(matrix, traits, filename, p): + """ + Expresses the same information as the neato file, only in + eXtensible Graph Markup and Modeling Language (XGMML) so the user can develop his/her + own graph in a program such as Cytoscape + """ + inputFile1 = open(filename + "_xgmml_symbol.txt", "w") + inputFile2 = open(filename + "_xgmml_name.txt", "w") + inputFile3 = open(filename + "_plain_symbol.txt", "w") + inputFile4 = open(filename + "_plain_name.txt", "w") + + inputFile1.write("<graph directed=\"1\" label=\"Network Graph\">\n") + inputFile2.write("<graph directed=\"1\" label=\"Network Graph\">\n") + + #Write out nodes + traitEdges = [] + for i in range(0, len(traits)): + traitEdges.append(0) + + for i in range(0, len(traits)): + + labelName = traits[i].symbol + inputFile1.write("\t<node id=\"%s\" label=\"%s\"></node>\n" % (i, labelName)) + + for i in range(0, len(traits)): + + labelName = traits[i].name + inputFile2.write("\t<node id=\"%s\" label=\"%s\"></node>\n" % (i, labelName)) + + #Write out edges + for point in matrix: + + traitEdges[point.i] = 1 + traitEdges[point.j] = 1 + if p["edges"] == "complex": + _traitValue = "%.3f" % point.value + inputFile1.write("\t<edge source=\"%s\" target=\"%s\" label=\"%s\"></edge>\n" + % (point.i, + point.j, + _traitValue)) + inputFile2.write("\t<edge source=\"%s\" target=\"%s\" label=\"%s\"></edge>\n" + % (point.i, + point.j, + _traitValue)) + + inputFile1.write("</graph>") + inputFile2.write("</graph>") + + for edge in matrix: + inputFile3.write("%s\t%s\t%s\n" % (traits[edge.i].symbol, edge.value, traits[edge.j].symbol)) + + + for edge in matrix: + inputFile4.write("%s\t%s\t%s\n" % (traits[edge.i].name, edge.value, traits[edge.j].name)) + + inputFile1.close() + inputFile2.close() + inputFile3.close() + inputFile4.close() + + return (os.path.split(filename))[1] + +# writeNeatoFile : DataMatrix -> arrayof Traits -> String -> ParamDict -> String +def writeNeatoFile(matrix, traits, filename, GeneIdArray, p): + """ + Given input data, to write a valid input file for neato, optionally + writing entries for nodes that have no edges. + + NOTE: There is a big difference between removing an edge and zeroing + its value. Because writeNeatoFile is edge-driven, zeroing an edge's value + will still result in its node being written. + """ + inputFile = open(filename, "w") + + """ + This file (inputFile_pdf) is rotated 90 degrees. This is because of a bug in graphviz + that causes pdf output onto a non-landscape layout to often be cut off at the edge + of the page. This second filename (which is just the first + "_pdf" is then read + in the "visualizePage" class in networkGraph.py and used to generate the postscript + file that is converted to pdf. + """ + inputFile_pdf = open(filename + "_pdf", "w") + + + if p["splines"] == "yes": + splines = "true" + else: + splines = "false" + + # header + inputFile.write('''graph webqtlGraph { + overlap="false"; + start="regular"; + splines="%s"; + ratio="auto"; + fontpath = "%s"; + node [fontname="%s", fontsize=%s, shape="%s"]; + edge [fontname="%s", fontsize=%s]; + ''' % (splines, webqtlConfig.PIDDLE_FONT_PATH, + p["nfont"], p["nfontsize"], p["nodeshapeType"], + p["cfont"], p["cfontsize"])) + + inputFile_pdf.write('''graph webqtlGraph { + overlap="false"; + start="regular"; + splines="%s"; + rotate="90"; + center="true"; + size="11,8.5"; + margin="0"; + ratio="fill"; + fontpath = "%s"; + node [fontname="%s", fontsize=%s, shape="%s"]; + edge [fontname="%s", fontsize=%s]; + ''' % (splines, webqtlConfig.PIDDLE_FONT_PATH, + p["nfont"], p["nfontsize"], p["nodeshapeType"], + p["cfont"], p["cfontsize"])) + + # traitEdges stores whether a particular trait has edges + traitEdges = [] + for i in range(0, len(traits)): + traitEdges.append(0) + + if p["dispcorr"] == "yes": + _dispCorr = 1 + else: + _dispCorr = 0 + # print edges first while keeping track of nodes + for point in matrix: + if point.value != 0: + traitEdges[point.i] = 1 + traitEdges[point.j] = 1 + if p["edges"] == "complex": + if _dispCorr: + _traitValue = "%.3f" % point.value + else: + _traitValue = "" + if p["correlationName"] == "Pearson": + inputFile.write('%s -- %s [len=%s, weight=%s, label=\"%s\", color=\"%s\", style=\"%s\", edgeURL=\"javascript:showCorrelationPlot2(db=\'%s\',ProbeSetID=\'%s\',CellID=\'\',db2=\'%s\',ProbeSetID2=\'%s\',CellID2=\'\',rank=\'%s\');\", edgetooltip="%s"];\n' + % (point.i, + point.j, + point.length, + point.length, + _traitValue, + point.color, + point.style, + str(traits[point.i].datasetName()), + str(traits[point.i].nameNoDB()), + str(traits[point.j].datasetName()), + str(traits[point.j].nameNoDB()), + "0", + "Pearson Correlation Plot between " + str(traits[point.i].symbol) + " and " + str(traits[point.j].symbol))) + elif p["correlationName"] == "Spearman": + inputFile.write('%s -- %s [len=%s, weight=%s, label=\"%s\", color=\"%s\", style=\"%s\", edgeURL=\"javascript:showCorrelationPlot2(db=\'%s\',ProbeSetID=\'%s\',CellID=\'\',db2=\'%s\',ProbeSetID2=\'%s\',CellID2=\'\',rank=\'%s\');\", edgetooltip="%s"];\n' + % (point.i, + point.j, + point.length, + point.length, + _traitValue, + point.color, + point.style, + str(traits[point.j].datasetName()), + str(traits[point.j].nameNoDB()), + str(traits[point.i].datasetName()), + str(traits[point.i].nameNoDB()), + "1", + "Spearman Correlation Plot between " + str(traits[point.i].symbol) + " and " + str(traits[point.j].symbol))) + elif p["correlationName"] == "Tissue": + inputFile.write('%s -- %s [len=%s, weight=%s, label=\"%s\", color=\"%s\", style=\"%s\", edgeURL=\"javascript:showTissueCorrPlot(fmName=\'showDatabase\', X_geneSymbol=\'%s\', Y_geneSymbol=\'%s\', rank=\'0\');\", edgetooltip="%s"];\n' + % (point.i, + point.j, + point.length, + point.length, + _traitValue, + point.color, + point.style, + str(traits[point.i].symbol), + str(traits[point.j].symbol), + "Tissue Correlation Plot between " + str(traits[point.i].symbol) + " and " + str(traits[point.j].symbol))) + else: + inputFile.write('%s -- %s [len=%s, weight=%s, label=\"%s\", color=\"%s\", style=\"%s\", edgeURL=\"javascript:showCorrelationPlot2(db=\'%s\',ProbeSetID=\'%s\',CellID=\'\',db2=\'%s\',ProbeSetID2=\'%s\',CellID2=\'\',rank=\'%s\');\", edgetooltip="%s"];\n' + % (point.i, + point.j, + point.length, + point.length, + _traitValue, + point.color, + point.style, + str(traits[point.i].datasetName()), + str(traits[point.i].nameNoDB()), + str(traits[point.j].datasetName()), + str(traits[point.j].nameNoDB()), + "0", + "Correlation Plot between " + str(traits[point.i].symbol) + " and " + str(traits[point.j].symbol))) + inputFile_pdf.write('%s -- %s [len=%s, weight=%s, label=\"%s\", color=\"%s\", style=\"%s\", edgetooltip="%s"];\n' + % (point.i, + point.j, + point.length, + point.length, + _traitValue, + point.color, + point.style, + "Correlation Plot between " + str(traits[point.i].symbol) + " and " + str(traits[point.j].symbol))) + + else: + inputFile.write('%s -- %s [color="%s", style="%s"];\n' + % (point.i, + point.j, + point.color, + point.style)) + inputFile_pdf.write('%s -- %s [color="%s", style="%s"];\n' + % (point.i, + point.j, + point.color, + point.style)) + + # now print nodes + # the target attribute below is undocumented; I found it by looking + # in the neato code + for i in range(0, len(traits)): + if traitEdges[i] == 1 or p["printIslands"] == 1: + _tname = str(traits[i]) + if _tname.find("Publish") > 0: + plotColor = p["cPubName"] + elif _tname.find("Geno") > 0: + plotColor = p["cGenName"] + else: + plotColor = p["cMicName"] + if p['nodelabel'] == 'yes': + labelName = _tname + else: + labelName = traits[i].symbol + + inputFile.write('%s [label="%s", href="javascript:showDatabase2(\'%s\',\'%s\',\'\');", color="%s", style = "filled"];\n' + % (i, labelName, traits[i].datasetName(), traits[i].nameNoDB(), plotColor))# traits[i].color + inputFile_pdf.write('%s [label="%s", href="javascript:showDatabase2(\'%s\',\'%s\',\'\');", color="%s", style = "filled"];\n' + % (i, labelName, traits[i].datasetName(), traits[i].nameNoDB(), plotColor))# traits[i].color + + # footer + inputFile.write("}\n") + inputFile_pdf.write("]\n") + inputFile.close() + inputFile_pdf.close() + + # return only the filename portion, omitting the directory + return (os.path.split(filename))[1] + +# runNeato : string -> string -> string +def runNeato(filename, extension, format, gType): + """ + to run neato on the dataset in the given filename and produce an image file + in the given format whose name we will return. Right now we assume + that format is a valid neato output (see graphviz docs) and a valid extension + for the source datafile. For example, + runNeato('input1', 'png') will produce a file called 'input1.png' + by invoking 'neato input1 -Tpng -o input1.png' + """ + # trim extension off of filename before adding output extension + if filename.find(".") > 0: + filenameBase = filename[:filename.find(".")] + else: + filenameBase = filename + + imageFilename = filenameBase + "." + extension + + #choose which algorithm to run depended upon parameter gType + #neato: energy based algorithm + #circular: nodes given circular structure determined by which nodes are most closely correlated + #radial: first node listed (when you search) is center of the graph, all other nodes are in a circular structure around it + #fdp: force based algorithm + + if gType == "none": + # to keep the output of neato from going to stdout, we open a pipe + # and then wait for it to terminate + + if format in ('gif', 'cmapx', 'ps'): + neatoExit = os.spawnlp(os.P_WAIT, "/usr/local/bin/neato", "/usr/local/bin/neato", "-s", "-T", format, webqtlConfig.IMGDIR + filename, "-o", webqtlConfig.IMGDIR + imageFilename) + + else: + neatoExit = os.spawnlp(os.P_WAIT, "/usr/local/bin/neato", "/usr/local/bin/neato", webqtlConfig.IMGDIR + filename, "-T", format, "-o", webqtlConfig.IMGDIR + imageFilename) + + if neatoExit == 0: + return imageFilename + + return imageFilename + + + elif gType == "neato": + # to keep the output of neato from going to stdout, we open a pipe + # and then wait for it to terminate + if format in ('gif', 'cmapx', 'ps'): + neatoExit = os.spawnlp(os.P_WAIT, "/usr/local/bin/neato", "/usr/local/bin/neato", "-s", "-T", format, webqtlConfig.IMGDIR + filename, "-o", webqtlConfig.IMGDIR + imageFilename) + + else: + neatoExit = os.spawnlp(os.P_WAIT, "/usr/local/bin/neato", "/usr/local/bin/neato", webqtlConfig.IMGDIR + filename, "-T", format, "-o", webqtlConfig.IMGDIR + imageFilename) + + if neatoExit == 0: + return imageFilename + + return imageFilename + + elif gType == "circular": + + if format in ('gif', 'cmapx', 'ps'): + neatoExit = os.spawnlp(os.P_WAIT, "/usr/local/bin/circo", "/usr/local/bin/circo", "-s", "-T", format, webqtlConfig.IMGDIR + filename, "-o", webqtlConfig.IMGDIR + imageFilename) + + else: + neatoExit = os.spawnlp(os.P_WAIT, "/usr/local/bin/circo", "/usr/local/bin/circo", webqtlConfig.IMGDIR + filename, "-T", format, "-o", webqtlConfig.IMGDIR + imageFilename) + + if neatoExit == 0: + return imageFilename + + return imageFilename + + elif gType == "radial": + + if format in ('gif', 'cmapx', 'ps'): + neatoExit = os.spawnlp(os.P_WAIT, "/usr/local/bin/twopi", "/usr/local/bin/twopi", "-s", "-T", format, webqtlConfig.IMGDIR + filename, "-o", webqtlConfig.IMGDIR + imageFilename) + + else: + neatoExit = os.spawnlp(os.P_WAIT, "/usr/local/bin/twopi", "/usr/local/bin/twopi", webqtlConfig.IMGDIR + filename, "-T", format, "-o", webqtlConfig.IMGDIR + imageFilename) + + if neatoExit == 0: + return imageFilename + + return imageFilename + + elif gType == "fdp": + + if format in ('gif', 'cmapx', 'ps'): + neatoExit = os.spawnlp(os.P_WAIT, "/usr/local/bin/fdp", "/usr/local/bin/fdp", "-s", "-T", format, webqtlConfig.IMGDIR + filename, "-o", webqtlConfig.IMGDIR + imageFilename) + + else: + neatoExit = os.spawnlp(os.P_WAIT, "/usr/local/bin/fdp", "/usr/local/bin/fdp", webqtlConfig.IMGDIR + filename, "-T", format, "-o", webqtlConfig.IMGDIR + imageFilename) + + if neatoExit == 0: + return imageFilename + + return imageFilename + + + return imageFilename +# runPsToPdf: string -> int -> intstring +# to run Ps2Pdf to convert the given input postscript file to an 8.5 by 11 +# pdf file The width and height should be specified in inches. We assume +# that the PS files output by GraphViz are 72 dpi. +def runPsToPdf(psfile, width, height): + # we add 1 for padding b/c sometimes a small part of the graph gets + # cut off + newwidth = int((width + 1) * 720) + newheight = int((height + 1) * 720) + + # replace the ps extension with a pdf one + pdffile = psfile[:-2] + "pdf" + + os.spawnlp(os.P_WAIT, "ps2pdf", + "-g%sx%s" % (newwidth, newheight), + webqtlConfig.IMGDIR + psfile, webqtlConfig.IMGDIR + pdffile) + + return pdffile + +# buildParamDict: void -> ParamDict +# to process and validate CGI arguments, +# looking up human-readable names where necessary +# see the comment at the top of the file for valid cgi parameters +def buildParamDict(fs, sessionfile): + params = {} + + params["inputFile"] = fs.formdata.getvalue("inputFile", "") + params["progress"] = fs.formdata.getvalue("progress", "1") + params["filename"] = fs.formdata.getvalue("filename", "") + params["session"] = sessionfile + + if type("1") != type(fs.formdata.getvalue("searchResult")): + params["searchResult"] = string.join(fs.formdata.getvalue("searchResult"),'\t') + else: + params["searchResult"] = fs.formdata.getvalue("searchResult") + + params["riset"] = fs.formdata.getvalue("RISet", "") + #if params["filename"] == "": + # raise nGraphException("Required parameter filename missing") + + #parameter determining whether export button returns an xgmml graph file or plain text file + params["exportFormat"] = fs.formdata.getvalue("exportFormat", "xgmml") + + #parameter determining whether or not traits in the graph file are listed by their symbol or name + params["traitType"] = fs.formdata.getvalue("traitType", "symbol") + + #parameter saying whether or not graph structure should be locked when you redraw the graph + params["lock"] = fs.formdata.getvalue("lock", "no") + + #parameter saying what algorithm should be used to draw the graph + params["gType"] = fs.formdata.getvalue("gType", "none") + + params["kValue"] = webqtlUtil.safeFloat(fs.formdata.getvalue("kValue", "0.5"), 0.5) + params["whichValue"] = webqtlUtil.safeInt(fs.formdata.getvalue("whichValue","0"),0) + + # 1 inch = 2.54 cm + # 1 cm = 0.3937 inch + + params["width"] = webqtlUtil.safeFloat(fs.formdata.getvalue("width", "40.0"), 40.0) + params["height"] = webqtlUtil.safeFloat(fs.formdata.getvalue("height", "40.0"), 40.0) + + yesno = ["yes", "no"] + + params["tune"] = webqtlUtil.safeString(fs.formdata.getvalue("tune", "yes"), yesno, "yes") + + params["printIslands"] = webqtlUtil.safeInt(fs.formdata.getvalue("printIslands", "1"),1) + params["nodeshape"] = webqtlUtil.safeString(fs.formdata.getvalue("nodeshape","yes"), yesno, "yes") + params["nodelabel"] = webqtlUtil.safeString(fs.formdata.getvalue("nodelabel","no"), yesno, "no") + params["nfont"] = fs.formdata.getvalue("nfont","Arial") + params["nfontsize"] = webqtlUtil.safeFloat(fs.formdata.getvalue("nfontsize", "10.0"), 10.0) + + params["splines"] = webqtlUtil.safeString(fs.formdata.getvalue("splines","yes"), yesno, "yes") + params["dispcorr"] = webqtlUtil.safeString(fs.formdata.getvalue("dispcorr","no"), yesno, "no") + params["cfont"] = fs.formdata.getvalue("cfont","Arial") + params["cfontsize"] = webqtlUtil.safeFloat(fs.formdata.getvalue("cfontsize", "10.0"), 10.0) + + params["cPubName"] = fs.formdata.getvalue("cPubName","palegreen") + params["cMicName"] = fs.formdata.getvalue("cMicName","lightblue") + params["cGenName"] = fs.formdata.getvalue("cGenName","lightcoral") + + params["cPubColor"] = fs.formdata.getvalue("cPubColor","98fb98") + params["cMicColor"] = fs.formdata.getvalue("cMicColor","add8e6") + params["cGenColor"] = fs.formdata.getvalue("cGenColor","f08080") + + params["cL1Name"] = fs.formdata.getvalue("cL1Name","blue") + params["cL2Name"] = fs.formdata.getvalue("cL2Name","green") + params["cL3Name"] = fs.formdata.getvalue("cL3Name","black") + params["cL4Name"] = fs.formdata.getvalue("cL4Name","pink") + params["cL5Name"] = fs.formdata.getvalue("cL5Name","orange") + params["cL6Name"] = fs.formdata.getvalue("cL6Name","red") + + params["cL1Color"] = fs.formdata.getvalue("cL1Color","0000ff") + params["cL2Color"] = fs.formdata.getvalue("cL2Color","00ff00") + params["cL3Color"] = fs.formdata.getvalue("cL3Color","000000") + params["cL4Color"] = fs.formdata.getvalue("cL4Color","ffc0cb") + params["cL5Color"] = fs.formdata.getvalue("cL5Color","ffa500") + params["cL6Color"] = fs.formdata.getvalue("cL6Color","ff0000") + + params["L1style"] = fs.formdata.getvalue("L1style","bold") + params["L2style"] = fs.formdata.getvalue("L2style","") + params["L3style"] = fs.formdata.getvalue("L3style","dashed") + params["L4style"] = fs.formdata.getvalue("L4style","dashed") + params["L5style"] = fs.formdata.getvalue("L5style","") + params["L6style"] = fs.formdata.getvalue("L6style","bold") + + if params["splines"] == "yes": + params["splineName"] = "curves" + else: + params["splineName"] = "lines" + + if params["nodeshape"] == "yes": + params["nodeshapeType"] = "box" + else: + params["nodeshapeType"] = "ellipse" + + if params["whichValue"] == 0: + params["correlationName"] = "Pearson" + elif params["whichValue"] == 1: + params["correlationName"] = "Spearman" + elif params["whichValue"] == 2: + params["correlationName"] = "Literature" + else: + params["correlationName"] = "Tissue" + + # see graphviz::writeNeatoFile to find out what this done + params["edges"] = "complex" + + return params + +def optimalRadialNode(matrix): + """ + Automatically determines the node with the most/strongest correlations with + other nodes. If the user selects "radial" for Graph Type and then "Auto" for the + central node then this node is used as the central node. The algorithm is simply a sum of + each node's correlations that fall above the threshold set by the user. + """ + + optMatrix = [0]*(len(matrix)+1) + + for pt in matrix: + if abs(pt.value) > 0.5: + optMatrix[pt.i] += abs(pt.value) + optMatrix[pt.j] += abs(pt.value) + + optPoint = 0 + optCorrTotal = 0 + + j = 0 + + for point in optMatrix: + if (float(point) > float(optCorrTotal)): + optPoint = j + optCorrTotal = point + j += 1 + + + return optPoint + +# filterDataMatrix : DataMatrix -> ParamDict -> DataMatrix +def filterDataMatrix(matrix, p): + """ + To convert a set of input RawPoints to a set of + ProcessedPoints and to choose the appropriate + correlation coefficent. + """ + newmatrix = [] + for pt in matrix: + pt2 = ProcessedPoint(pt.i, pt.j) # XZ, 09/11/2008: add module name + + # pick right value + if p["whichValue"] == 0: + pt2.value = pt.pearson + elif p["whichValue"] == 1: + pt2.value = pt.spearman + elif p["whichValue"] == 2: + pt2.value = pt.literature + elif p["whichValue"] == 3: + pt2.value = pt.tissue + else: + raise nGraphException("whichValue should be either 0, 1, 2 or 3") + + try: + pt2.value = float(pt2.value) + except: + pt2.value = 0.00 + + newmatrix.append(pt2) + + + + return newmatrix + +def generateSymbolList(traits): + """ + Generates a list of trait symbols to be displayed in the central node + selection drop-down menu when plotting a radial graph + """ + + traitList = traits + + symbolList = [None]*len(traitList) + + i=0 + for trait in traitList: + symbolList[i] = str(trait.symbol) + i = i+1 + + symbolListString = "\t".join(symbolList) + + return symbolListString + |