Add all the source codes into the github.

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       
+