# 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 Zach 12/14/2010
import datetime
import string
from math import *
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
from PIL import ImageColor
import os
import json
import htmlgen as HT
from gn2.base import webqtlConfig
from gn2.base.GeneralObject import GeneralObject
from gn2.utility import webqtlUtil
from gn2.utility import Plot
from gn2.utility.tools import get_setting
from gn2.wqflask.interval_analyst import GeneUtil
from gn2.base.webqtlConfig import GENERATED_IMAGE_DIR
from gn2.utility.pillow_utils import draw_rotated_text, draw_open_polygon
from gn2.wqflask.database import database_connection
try: # Only import this for Python3
from functools import reduce
except:
pass
RED = ImageColor.getrgb("red")
BLUE = ImageColor.getrgb("blue")
GRAY = ImageColor.getrgb("gray")
GOLD = ImageColor.getrgb("gold")
BLACK = ImageColor.getrgb("black")
GREEN = ImageColor.getrgb("green")
PURPLE = ImageColor.getrgb("purple")
ORANGE = ImageColor.getrgb("orange")
YELLOW = ImageColor.getrgb("yellow")
DARKRED = ImageColor.getrgb("darkred")
DARKBLUE = ImageColor.getrgb("darkblue")
DARKGRAY = ImageColor.getrgb("darkgray")
DEEPPINK = ImageColor.getrgb("deeppink")
DARKGREEN = ImageColor.getrgb("darkgreen")
GAINSBORO = ImageColor.getrgb("gainsboro")
LIGHTBLUE = ImageColor.getrgb("lightblue")
DARKORANGE = ImageColor.getrgb("darkorange")
DARKVIOLET = ImageColor.getrgb("darkviolet")
MEDIUMPURPLE = ImageColor.getrgb("mediumpurple")
# ---- END: Define common colours ---- #
# ZS: List of distinct colors for manhattan plot if user selects "varied"
COLOR_CODES = ["#FF0000", "#00FF00", "#0000FF", "#FFFF00", "#FF00FF", "#00FFFF",
"#000000", "#800000", "#008000", "#000080", "#808000", "#800080",
"#008080", "#808080", "#C00000", "#00C000", "#0000C0", "#C0C000",
"#C000C0", "#00C0C0", "#C0C0C0", "#400000", "#004000", "#000040"]
DISTINCT_COLOR_LIST = [ImageColor.getrgb(color) for color in COLOR_CODES]
# ---- FONT FILES ---- #
VERDANA_FILE = "./gn2/wqflask/static/fonts/verdana.ttf"
VERDANA_BOLD_FILE = "./gn2/wqflask/static/fonts/verdanab.ttf"
TREBUC_FILE = "./gn2/wqflask/static/fonts/trebucbd.ttf"
FNT_BS_FILE = "./gn2/wqflask/static/fonts/fnt_bs.ttf"
ARIAL_FILE = "./gn2/wqflask/static/fonts/arial.ttf"
assert(os.path.isfile(VERDANA_FILE))
class HtmlGenWrapper:
"""Wrapper Methods for HTML gen"""
@staticmethod
def create_image_tag(**kwargs):
image = HT.Image("", "")
for key, value in list(kwargs.items()):
image.set_attribute(key, value)
return image
@staticmethod
def create_form_tag(**kwargs):
form = HT.Form("POST", "") # Default method is POST
for key, value in list(kwargs.items()):
if key == "submit":
form.append(value)
continue
form.set_attribute(key.replace("cgi", "action"), str(value))
return form
@staticmethod
def create_p_tag(**kwargs):
paragraph = HT.Paragraph()
for key, value in list(kwargs.items()):
paragraph.set_attribute(key, value)
return paragraph
@staticmethod
def create_br_tag():
return HT.VoidElement("br")
@staticmethod
def create_input_tag(**kwargs):
input_ = HT.Input()
for key, value in list(kwargs.items()):
input_.set_attribute(key.lower().replace("_", ""), value)
return input_
@staticmethod
def create_area_tag(**kwargs):
area = HT.VoidElement("area")
for key, value in list(kwargs.items()):
area.set_attribute(key, value)
return area
@staticmethod
def create_link_tag(href, content, **kwargs):
link = HT.Link(href, content)
for key, value in list(kwargs.items()):
link.set_attribute(key, value)
return link
@staticmethod
def create_map_tag(**kwargs):
map_ = HT.Element("map")
for key, value in list(kwargs.items()):
map_.set_attribute(key, value)
return map_
class DisplayMappingResults:
"""Inteval Mapping Plot Page"""
cMGraphInterval = 5
GRAPH_MIN_WIDTH = 900
GRAPH_MAX_WIDTH = 10000 # Don't set this too high
GRAPH_DEFAULT_WIDTH = 1280
MULT_GRAPH_DEFAULT_WIDTH = 2000
MULT_GRAPH_MIN_WIDTH = 1400
MULT_GRAPH_DEFAULT_WIDTH = 1600
GRAPH_DEFAULT_HEIGHT = 600
# Display order:
# UCSC BAND =========
# ENSEMBL BAND -=-=-=
# ** GENES **********
BAND_SPACING = 4
BAND_HEIGHT = 10
BAND_HEIGHT = 10
BAND_HEIGHT = 10
NUM_GENE_ROWS = 10
EACH_GENE_HEIGHT = 6 # number of pixels tall, for each gene to display
EACH_GENE_ARROW_WIDTH = 5
EACH_GENE_ARROW_SPACING = 14
DRAW_DETAIL_MB = 4
DRAW_UTR_LABELS_MB = 4
qmarkImg = HtmlGenWrapper.create_image_tag(
src='/images/qmarkBoxBlue.gif',
width="10", height="13", border="0", alt='Glossary'
)
# Note that "qmark.gif" is a similar, smaller, rounded-edges
# question mark. It doesn't look like the ones on the image,
# though, which is why we don't use it here.
HELP_WINDOW_NAME = 'helpWind'
# BEGIN HaplotypeAnalyst
NR_INDIVIDUALS = 0
# END HaplotypeAnalyst
ALEX_DEBUG_BOOL_PRINT_GENE_LIST = 1
kONE_MILLION = 1000000
LODFACTOR = 4.61
SNP_COLOR = ORANGE # Color for the SNP "seismograph"
TRANSCRIPT_LOCATION_COLOR = MEDIUMPURPLE
BOOTSTRAP_BOX_COLOR = YELLOW
LRS_COLOR = ImageColor.getrgb("#0000FF")
SIGNIFICANT_COLOR = ImageColor.getrgb("#EBC7C7")
SUGGESTIVE_COLOR = GAINSBORO
SIGNIFICANT_WIDTH = 5
SUGGESTIVE_WIDTH = 5
ADDITIVE_COLOR_POSITIVE = GREEN
ADDITIVE_COLOR_NEGATIVE = ORANGE
DOMINANCE_COLOR_POSITIVE = DARKVIOLET
DOMINANCE_COLOR_NEGATIVE = RED
# BEGIN HaplotypeAnalyst
HAPLOTYPE_POSITIVE = BLUE
HAPLOTYPE_NEGATIVE = RED
HAPLOTYPE_HETEROZYGOUS = ORANGE
HAPLOTYPE_RECOMBINATION = DARKGRAY
# END HaplotypeAnalyst
TOP_RIGHT_INFO_COLOR = BLACK
CLICKABLE_WEBQTL_REGION_COLOR = ImageColor.getrgb("#F5D3D3")
CLICKABLE_WEBQTL_REGION_OUTLINE_COLOR = ImageColor.getrgb("#FCE9E9")
CLICKABLE_WEBQTL_TEXT_COLOR = ImageColor.getrgb("#912828")
CLICKABLE_PHENOGEN_REGION_COLOR = ImageColor.getrgb("#A2FB94")
CLICKABLE_PHENOGEN_REGION_OUTLINE_COLOR = ImageColor.getrgb("#CEFEC7")
CLICKABLE_PHENOGEN_TEXT_COLOR = ImageColor.getrgb("#1FD504")
CLICKABLE_UCSC_REGION_COLOR = ImageColor.getrgb("#DDDDEE")
CLICKABLE_UCSC_REGION_OUTLINE_COLOR = ImageColor.getrgb("#EDEDFF")
CLICKABLE_UCSC_TEXT_COLOR = ImageColor.getrgb("#333366")
CLICKABLE_ENSEMBL_REGION_COLOR = ImageColor.getrgb("#EEEEDD")
CLICKABLE_ENSEMBL_REGION_OUTLINE_COLOR = ImageColor.getrgb("#FEFEEE")
CLICKABLE_ENSEMBL_TEXT_COLOR = ImageColor.getrgb("#555500")
GRAPH_BACK_LIGHT_COLOR = ImageColor.getrgb("#FBFBFF")
GRAPH_BACK_DARK_COLOR = ImageColor.getrgb("#F1F1F9")
HELP_PAGE_REF = '/glossary.html'
def __init__(self, start_vars):
self.temp_uuid = start_vars['temp_uuid']
self.hash_of_inputs = start_vars['hash_of_inputs']
self.dataid = start_vars['dataid']
self.dataset = start_vars['dataset']
self.this_trait = start_vars['this_trait']
self.n_samples = start_vars['n_samples']
self.species = start_vars['species']
self.genofile_string = ""
if 'genofile_string' in start_vars:
self.genofile_string = start_vars['genofile_string']
self.geno_db_exists = start_vars['geno_db_exists']
self.first_run = True
if 'first_run' in start_vars:
self.first_run = start_vars['first_run']
if 'temp_trait' in start_vars and start_vars['temp_trait'] != "False":
self.temp_trait = "True"
self.group = start_vars['group']
# Needing for form submission when doing single chr
# mapping or remapping after changing options
self.sample_vals = start_vars['sample_vals']
self.vals_hash= start_vars['vals_hash']
self.sample_vals_dict = json.loads(self.sample_vals)
self.transform = start_vars['transform']
self.mapping_method = start_vars['mapping_method']
self.mapping_results_path = start_vars['mapping_results_path']
if self.mapping_method == "rqtl_geno":
self.mapmethod_rqtl = start_vars['method']
self.mapmodel_rqtl = start_vars['model']
self.pair_scan = start_vars['pair_scan']
self.js_data = start_vars['js_data']
# Top markers to display in table
self.trimmed_markers = start_vars['trimmed_markers']
if self.dataset.group.species == "rat":
self._ucscDb = "rn6"
elif self.dataset.group.species == "mouse":
self._ucscDb = "mm10"
else:
self._ucscDb = ""
#####################################
# Options
#####################################
# Mapping options
if start_vars['mapping_scale'] != "":
self.plotScale = start_vars['mapping_scale']
else:
self.plotScale = "physic"
self.manhattan_plot = start_vars['manhattan_plot']
if self.manhattan_plot:
self.color_scheme = "alternating"
if 'color_scheme' in start_vars:
self.color_scheme = start_vars['color_scheme']
if self.color_scheme == "single":
self.manhattan_single_color = ImageColor.getrgb(
"#" + start_vars['manhattan_single_color'])
if 'permCheck' in list(start_vars.keys()):
self.permChecked = start_vars['permCheck']
else:
self.permChecked = False
if start_vars['num_perm'] > 0:
self.nperm = int(start_vars['num_perm'])
if self.permChecked:
self.perm_output = start_vars['perm_output']
self.suggestive = start_vars['suggestive']
self.significant = start_vars['significant']
else:
self.nperm = 0
if 'bootCheck' in list(start_vars.keys()):
self.bootChecked = start_vars['bootCheck']
else:
self.bootChecked = False
if 'num_bootstrap' in list(start_vars.keys()):
self.nboot = int(start_vars['num_bootstrap'])
else:
self.nboot = 0
if 'bootstrap_results' in list(start_vars.keys()):
self.bootResult = start_vars['bootstrap_results']
else:
self.bootResult = []
if 'do_control' in list(start_vars.keys()):
self.doControl = start_vars['do_control']
else:
self.doControl = "false"
if 'control_marker' in list(start_vars.keys()):
self.controlLocus = start_vars['control_marker']
else:
self.controlLocus = ""
if 'covariates' in list(start_vars.keys()):
self.covariates = start_vars['covariates']
if 'maf' in list(start_vars.keys()):
self.maf = start_vars['maf']
else:
self.maf = ""
if 'output_files' in list(start_vars.keys()):
self.output_files = start_vars['output_files']
if 'use_loco' in list(start_vars.keys()) and self.mapping_method == "gemma":
self.use_loco = start_vars['use_loco']
if self.mapping_method == "reaper":
if 'output_files' in start_vars:
self.output_files = ",".join(
[(the_file if the_file is not None else "") for the_file in start_vars['output_files']])
self.categorical_vars = ""
self.perm_strata = ""
if 'perm_strata' in list(start_vars.keys()) and 'categorical_vars' in list(start_vars.keys()):
self.categorical_vars = start_vars['categorical_vars']
self.perm_strata = start_vars['perm_strata']
self.selectedChr = int(start_vars['selected_chr'])
self.strainlist = start_vars['samples']
self.traitList = []
thisTrait = start_vars['this_trait']
self.traitList.append(thisTrait)
################################################################
# Calculations QTL goes here
################################################################
self.multipleInterval = len(self.traitList) > 1
self.qtlresults = start_vars['qtl_results']
if self.multipleInterval:
self.colorCollection = Plot.colorSpectrum(len(self.qtlresults))
else:
self.colorCollection = [self.LRS_COLOR]
self.dataset.group.genofile = self.genofile_string.split(":")[0]
if self.mapping_method == "reaper" and self.manhattan_plot != True:
self.genotype = self.dataset.group.read_genotype_file(
use_reaper=True)
else:
self.genotype = self.dataset.group.read_genotype_file()
# Drawing Options
try:
if self.selectedChr > -1:
self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(
self.GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
else:
self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(
self.MULT_GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
except:
if self.selectedChr > -1:
self.graphWidth = self.GRAPH_DEFAULT_WIDTH
else:
self.graphWidth = self.MULT_GRAPH_DEFAULT_WIDTH
# BEGIN HaplotypeAnalyst
if 'haplotypeAnalystCheck' in list(start_vars.keys()):
self.haplotypeAnalystChecked = start_vars['haplotypeAnalystCheck']
else:
self.haplotypeAnalystChecked = False
# END HaplotypeAnalyst
self.graphHeight = self.GRAPH_DEFAULT_HEIGHT
self.dominanceChecked = False
if 'LRSCheck' in list(start_vars.keys()):
self.LRS_LOD = start_vars['LRSCheck']
else:
self.LRS_LOD = start_vars['score_type']
self.intervalAnalystChecked = True
self.draw2X = False
if 'additiveCheck' in list(start_vars.keys()):
self.additiveChecked = start_vars['additiveCheck']
else:
self.additiveChecked = False
if 'viewLegend' in list(start_vars.keys()):
self.legendChecked = start_vars['viewLegend']
else:
self.legendChecked = False
if 'showSNP' in list(start_vars.keys()):
self.SNPChecked = start_vars['showSNP']
else:
self.SNPChecked = False
if 'showHomology' in list(start_vars.keys()):
self.homologyChecked = start_vars['showHomology']
else:
self.homologyChecked = "ON"
if 'showGenes' in list(start_vars.keys()):
self.geneChecked = start_vars['showGenes']
else:
self.geneChecked = False
try:
self.startMb = float(start_vars['startMb'])
except:
self.startMb = -1
try:
self.endMb = float(start_vars['endMb'])
except:
self.endMb = -1
try:
self.lrsMax = float(start_vars['lrsMax'])
except:
self.lrsMax = 0
# Trait Infos
self.identification = ""
################################################################
# Generate Chr list and Retrieve Length Information
################################################################
self.ChrList = [("All", -1)]
for i, indChr in enumerate(self.genotype):
if self.dataset.group.species == "mouse" and indChr.name == "20":
self.ChrList.append(("X", i))
elif self.dataset.group.species == "rat" and indChr.name == "21":
self.ChrList.append(("X", i))
self.ChrList.append((indChr.name, i))
with database_connection(get_setting("SQL_URI")) as conn, conn.cursor() as cursor:
cursor.execute("SELECT Length FROM Chr_Length, InbredSet "
"WHERE Chr_Length.SpeciesId = InbredSet.SpeciesId "
"AND InbredSet.Name = %s AND Chr_Length.Name IN "
f"({', '.join(['%s' for x in self.ChrList[1:]])}) "
"ORDER BY Chr_Length.OrderId",
(self.dataset.group.name,
*[x[0] for x in self.ChrList[1:]],))
self.ChrLengthMbList = cursor.fetchall()
self.ChrLengthMbList = [x[0] / 1000000.0 for x in self.ChrLengthMbList]
self.ChrLengthMbSum = reduce(
lambda x, y: x + y, self.ChrLengthMbList, 0.0)
if self.ChrLengthMbList:
self.MbGraphInterval = self.ChrLengthMbSum / \
(len(self.ChrLengthMbList) * 12) # Empirical Mb interval
else:
self.MbGraphInterval = 1
self.ChrLengthCMList = []
for i, _chr in enumerate(self.genotype):
self.ChrLengthCMList.append(_chr[-1].cM - _chr[0].cM)
self.ChrLengthCMSum = reduce(
lambda x, y: x + y, self.ChrLengthCMList, 0.0)
if self.plotScale == 'physic':
self.GraphInterval = self.MbGraphInterval # Mb
else:
self.GraphInterval = self.cMGraphInterval # cM
#########################
# Get the sorting column
#########################
RISet = self.dataset.group.name
if RISet in ('AXB', 'BXA', 'AXBXA'):
self.diffCol = ['B6J', 'A/J']
elif RISet in ('BXD', 'BXD300', 'B6D2F2', 'BDF2-2005', 'BDF2-1999', 'BHHBF2', 'BXD-Harvested', 'BXD-Longevity', 'BXD-Micturition', 'BXD-AE', 'BXD-NIA-AD', 'B6D2RI', 'BXD-Bone', 'DOD-BXD-GWI', 'BXD-Heart-Metals', 'UTHSC-Cannabinoid'):
self.diffCol = ['B6J', 'D2J']
elif RISet in ('CXB'):
self.diffCol = ['CBY', 'B6J']
elif RISet in ('BXH', 'BHF2'):
self.diffCol = ['B6J', 'C3H']
elif RISet in ('B6BTBRF2'):
self.diffCol = ['B6J', 'BTB']
elif RISet in ('LXS'):
self.diffCol = ['ILS', 'ISS']
else:
self.diffCol = []
for i, strain in enumerate(self.diffCol):
with database_connection(get_setting("SQL_URI")) as conn, conn.cursor() as cursor:
cursor.execute("SELECT Id FROM Strain WHERE Symbol = %s",
(strain,))
if result := cursor.fetchone():
self.diffCol[i] = result[0]
################################################################
# GeneCollection goes here
################################################################
if self.plotScale == 'physic' and self.selectedChr != -1:
#StartMb or EndMb
if self.startMb < 0 or self.endMb < 0:
self.startMb = 0
self.endMb = self.ChrLengthMbList[self.selectedChr - 1]
geneTable = ""
self.geneCol = None
self.homology = None
if self.plotScale == 'physic' and self.selectedChr > -1 and (self.intervalAnalystChecked or self.geneChecked or self.homologyChecked):
# Draw the genes for this chromosome / region of this chromosome
webqtldatabase = self.dataset.name
if self.dataset.group.species == "mouse":
if self.selectedChr == 20:
chrName = "X"
else:
chrName = self.selectedChr
self.geneCol = GeneUtil.loadGenes(
str(chrName), self.diffCol, self.startMb, self.endMb, "mouse")
self.homology = GeneUtil.load_homology(str(chrName), self.startMb, self.endMb, "mouse_to_human.csv")
elif self.dataset.group.species == "rat":
if self.selectedChr == 21:
chrName = "X"
else:
chrName = self.selectedChr
self.geneCol = GeneUtil.loadGenes(
str(chrName), self.diffCol, self.startMb, self.endMb, "rat")
if self.geneCol and self.intervalAnalystChecked:
#######################################################################
#Nick use GENEID as RefGene to get Literature Correlation Informations#
#For Interval Mapping, Literature Correlation isn't useful, so skip it#
#through set GENEID is None #
#######################################################################
GENEID = None
self.geneTable(self.geneCol, GENEID)
# BEGIN HaplotypeAnalyst
# count the amount of individuals to be plotted, and increase self.graphHeight
if self.haplotypeAnalystChecked and self.selectedChr > -1:
thisTrait = self.this_trait
smd = []
for sample in self.sample_vals_dict.keys():
if self.sample_vals_dict[sample] != "x":
temp = GeneralObject(name=sample, value=float(
self.sample_vals_dict[sample]))
smd.append(temp)
else:
continue
samplelist = list(self.genotype.prgy)
for j, _geno in enumerate(self.genotype[0][1].genotype):
for item in smd:
if item.name == samplelist[j]:
self.NR_INDIVIDUALS = self.NR_INDIVIDUALS + 1
# default:
self.graphHeight = self.graphHeight + 2 * \
(self.NR_INDIVIDUALS + 10) * self.EACH_GENE_HEIGHT
# END HaplotypeAnalyst
if self.homologyChecked and self.homology and self.geneChecked and self.geneCol:
self.graphHeight = self.graphHeight + (self.NUM_GENE_ROWS) * self.EACH_GENE_HEIGHT
if self.geneChecked and self.geneCol:
self.graphHeight = self.graphHeight + (self.NUM_GENE_ROWS) * self.EACH_GENE_HEIGHT
################################################################
# Plots goes here
################################################################
showLocusForm = ""
intCanvas = Image.new("RGBA", size=(self.graphWidth, self.graphHeight))
gifmap = self.plotIntMapping(
intCanvas, startMb=self.startMb, endMb=self.endMb, showLocusForm=showLocusForm)
self.gifmap = gifmap.__str__()
self.filename = webqtlUtil.genRandStr("Itvl_")
intCanvas.save(
"{}.png".format(
os.path.join(webqtlConfig.GENERATED_IMAGE_DIR, self.filename)),
format='png')
intImg = HtmlGenWrapper.create_image_tag(
src="/image/{}.png".format(self.filename),
border="0", usemap='#WebQTLImageMap'
)
# Scales plot differently for high resolution
if self.draw2X:
intCanvasX2 = Image.new("RGBA", size=(
self.graphWidth * 2, self.graphHeight * 2))
gifmapX2 = self.plotIntMapping(
intCanvasX2, startMb=self.startMb, endMb=self.endMb, showLocusForm=showLocusForm, zoom=2)
intCanvasX2.save(
"{}.png".format(
os.path.join(webqtlConfig.GENERATED_IMAGE_DIR,
self.filename + "X2")),
format='png')
################################################################
# Outputs goes here
################################################################
# this form is used for opening Locus page or trait page, only available for genetic mapping
if showLocusForm:
showLocusForm = HtmlGenWrapper.create_form_tag(
cgi=os.path.join(webqtlConfig.CGIDIR, webqtlConfig.SCRIPTFILE),
enctype='multipart/form-data',
name=showLocusForm,
submit=HtmlGenWrapper.create_input_tag(type_='hidden'))
hddn = {'FormID': 'showDatabase', 'ProbeSetID': '_', 'database': fd.RISet + \
"Geno", 'CellID': '_', 'RISet': fd.RISet, 'incparentsf1': 'ON'}
for key in hddn.keys():
showLocusForm.append(HtmlGenWrapper.create_input_tag(
name=key, value=hddn[key], type_='hidden'))
showLocusForm.append(intImg)
else:
showLocusForm = intImg
if (self.permChecked and self.nperm > 0) and not (self.multipleInterval and 0 < self.nperm):
self.perm_filename = self.drawPermutationHistogram()
################################################################
# footnote goes here
################################################################
# Small('More information about this graph is available here.')
btminfo = HtmlGenWrapper.create_p_tag(id="smallsize")
if self.traitList and self.traitList[0].dataset and self.traitList[0].dataset.type == 'Geno':
btminfo.append(HtmlGenWrapper.create_br_tag())
btminfo.append(
'Mapping using genotype data as a trait will result in infinity LRS at one locus. In order to display the result properly, all LRSs higher than 100 are capped at 100.')
def plotIntMapping(self, canvas, offset=(80, 120, 110, 100), zoom=1, startMb=None, endMb=None, showLocusForm=""):
im_drawer = ImageDraw.Draw(canvas)
# calculating margins
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
if self.multipleInterval:
yTopOffset = max(90, yTopOffset)
else:
if self.legendChecked:
yTopOffset += 10
if self.covariates != "" and self.controlLocus and self.doControl != "false":
yTopOffset += 25
if len(self.transform) > 0:
yTopOffset += 5
else:
pass
if self.plotScale != 'physic':
yBottomOffset = max(120, yBottomOffset)
fontZoom = zoom
if zoom == 2:
xLeftOffset += 20
fontZoom = 1.5
xLeftOffset = int(xLeftOffset * fontZoom)
xRightOffset = int(xRightOffset * fontZoom)
yBottomOffset = int(yBottomOffset * fontZoom)
cWidth = canvas.size[0]
cHeight = canvas.size[1]
plotWidth = cWidth - xLeftOffset - xRightOffset
plotHeight = cHeight - yTopOffset - yBottomOffset
# Drawing Area Height
drawAreaHeight = plotHeight
if self.plotScale == 'physic' and self.selectedChr > -1:
if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
drawAreaHeight -= 4 * self.BAND_HEIGHT + 4 * self.BAND_SPACING + 10 * zoom
else:
drawAreaHeight -= 3 * self.BAND_HEIGHT + 3 * self.BAND_SPACING + 10 * zoom
if self.homologyChecked:
drawAreaHeight -= self.NUM_GENE_ROWS * \
self.EACH_GENE_HEIGHT + 3 * self.BAND_SPACING
if self.geneChecked:
drawAreaHeight -= self.NUM_GENE_ROWS * \
self.EACH_GENE_HEIGHT + 3 * self.BAND_SPACING
else:
if self.selectedChr > -1:
drawAreaHeight -= 20
else:
drawAreaHeight -= 30
# BEGIN HaplotypeAnalyst
if self.haplotypeAnalystChecked and self.selectedChr > -1:
drawAreaHeight -= self.EACH_GENE_HEIGHT * \
(self.NR_INDIVIDUALS + 10) * 2 * zoom
# END HaplotypeAnalyst
if zoom == 2:
drawAreaHeight -= 60
# Image map
gifmap = HtmlGenWrapper.create_map_tag(name="WebQTLImageMap")
newoffset = (xLeftOffset, xRightOffset, yTopOffset, yBottomOffset)
# Draw the alternating-color background first and get plotXScale
plotXScale = self.drawGraphBackground(
canvas, gifmap, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
# draw bootstap
if self.bootChecked and not self.multipleInterval:
self.drawBootStrapResult(canvas, self.nboot, drawAreaHeight, plotXScale,
offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
# Draw clickable region and gene band if selected
if self.plotScale == 'physic' and self.selectedChr > -1:
self.drawClickBand(canvas, gifmap, plotXScale, offset=newoffset,
zoom=zoom, startMb=startMb, endMb=endMb)
if self.geneChecked and self.geneCol:
self.drawGeneBand(canvas, gifmap, plotXScale, offset=newoffset,
zoom=zoom, startMb=startMb, endMb=endMb)
if self.homologyChecked and self.homology:
if self.geneChecked and self.geneCol:
yTopOffset = newoffset[3] + self.NUM_GENE_ROWS * \
self.EACH_GENE_HEIGHT + 3 * self.BAND_SPACING + 10
self.drawHomologyBand(canvas, gifmap, plotXScale, offset=(xLeftOffset, xRightOffset, yTopOffset, yBottomOffset),
zoom=zoom, startMb=startMb, endMb=endMb)
if self.SNPChecked:
self.drawSNPTrackNew(
canvas, offset=newoffset, zoom=2 * zoom, startMb=startMb, endMb=endMb)
# BEGIN HaplotypeAnalyst
if self.haplotypeAnalystChecked:
self.drawHaplotypeBand(
canvas, gifmap, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
# END HaplotypeAnalyst
# Draw X axis
self.drawXAxis(canvas, drawAreaHeight, gifmap, plotXScale, showLocusForm,
offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
# Draw QTL curve
self.drawQTL(canvas, drawAreaHeight, gifmap, plotXScale,
offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
# draw legend
if self.multipleInterval:
self.drawMultiTraitName(
fd, canvas, gifmap, showLocusForm, offset=newoffset)
elif self.legendChecked:
self.drawLegendPanel(canvas, offset=newoffset, zoom=zoom)
else:
pass
# draw position, no need to use a separate function
if self.traitList[0].mb: # Only draw if position actually exists
self.drawProbeSetPosition(
canvas, plotXScale, offset=newoffset, zoom=zoom)
return gifmap
def drawBootStrapResult(self, canvas, nboot, drawAreaHeight, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
im_drawer = ImageDraw.Draw(canvas)
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
yZero = canvas.size[1] - yBottomOffset
fontZoom = zoom
if zoom == 2:
fontZoom = 1.5
bootHeightThresh = drawAreaHeight * 3 / 4
# break bootstrap result into groups
BootCoord = []
i = 0
previous_chr = None
previous_chr_as_int = 0
startX = xLeftOffset
BootChrCoord = []
if self.selectedChr == -1: # ZS: If viewing full genome/all chromosomes
for i, result in enumerate(self.qtlresults):
if result['chr'] != previous_chr:
previous_chr = result['chr']
previous_chr_as_int += 1
if previous_chr_as_int != 1:
BootCoord.append(BootChrCoord)
BootChrCoord = []
startX += (
self.ChrLengthDistList[previous_chr_as_int - 2] + self.GraphInterval) * plotXScale
if self.plotScale == 'physic':
Xc = startX + (result['Mb'] - self.startMb) * plotXScale
else:
Xc = startX + \
(result['cM'] - self.qtlresults[0]['cM']) * plotXScale
BootChrCoord.append([Xc, self.bootResult[i]])
else:
for i, result in enumerate(self.qtlresults):
if str(result['chr']) == str(self.ChrList[self.selectedChr][0]):
if self.plotScale == 'physic':
Xc = startX + (result['Mb'] - \
self.startMb) * plotXScale
else:
Xc = startX + \
(result['cM'] - self.qtlresults[0]
['cM']) * plotXScale
BootChrCoord.append([Xc, self.bootResult[i]])
BootCoord = [BootChrCoord]
# reduce bootResult
if self.selectedChr > -1:
maxBootBar = 80.0
else:
maxBootBar = 200.0
stepBootStrap = plotWidth / maxBootBar
reducedBootCoord = []
maxBootCount = 0
for BootChrCoord in BootCoord:
nBoot = len(BootChrCoord)
bootStartPixX = BootChrCoord[0][0]
bootCount = BootChrCoord[0][1]
for i in range(1, nBoot):
if BootChrCoord[i][0] - bootStartPixX < stepBootStrap:
bootCount += BootChrCoord[i][1]
continue
else:
if maxBootCount < bootCount:
maxBootCount = bootCount
# end if
reducedBootCoord.append(
[bootStartPixX, BootChrCoord[i][0], bootCount])
bootStartPixX = BootChrCoord[i][0]
bootCount = BootChrCoord[i][1]
# end else
# end for
# add last piece
if BootChrCoord[-1][0] - bootStartPixX > stepBootStrap / 2.0:
reducedBootCoord.append(
[bootStartPixX, BootChrCoord[-1][0], bootCount])
else:
reducedBootCoord[-1][2] += bootCount
reducedBootCoord[-1][1] = BootChrCoord[-1][0]
# end else
if maxBootCount < reducedBootCoord[-1][2]:
maxBootCount = reducedBootCoord[-1][2]
# end if
for item in reducedBootCoord:
if item[2] > 0:
if item[0] < xLeftOffset:
item[0] = xLeftOffset
if item[0] > xLeftOffset + plotWidth:
item[0] = xLeftOffset + plotWidth
if item[1] < xLeftOffset:
item[1] = xLeftOffset
if item[1] > xLeftOffset + plotWidth:
item[1] = xLeftOffset + plotWidth
if item[0] != item[1]:
im_drawer.rectangle(
xy=((item[0], yZero),
(item[1], yZero - item[2] * bootHeightThresh / maxBootCount)),
fill=self.BOOTSTRAP_BOX_COLOR, outline=BLACK)
if maxBootCount == 0:
return
# draw boot scale
highestPercent = (maxBootCount * 100.0) / nboot
bootScale = Plot.detScale(0, highestPercent)
bootScale = Plot.frange(
bootScale[0], bootScale[1], bootScale[1] / bootScale[2])
bootScale = bootScale[:-1] + [highestPercent]
bootOffset = 50 * fontZoom
bootScaleFont = ImageFont.truetype(
font=VERDANA_FILE, size=13 * fontZoom)
im_drawer.rectangle(
xy=((canvas.size[0] - bootOffset, yZero - bootHeightThresh),
(canvas.size[0] - bootOffset - 15 * zoom, yZero)),
fill=YELLOW, outline=BLACK)
im_drawer.line(
xy=((canvas.size[0] - bootOffset + 4, yZero),
(canvas.size[0] - bootOffset, yZero)),
fill=BLACK)
TEXT_Y_DISPLACEMENT = -8
im_drawer.text(xy=(canvas.size[0] - bootOffset + 10, yZero + TEXT_Y_DISPLACEMENT), text='0%',
font=bootScaleFont, fill=BLACK)
for item in bootScale:
if item == 0:
continue
bootY = yZero - bootHeightThresh * item / highestPercent
im_drawer.line(
xy=((canvas.size[0] - bootOffset + 4, bootY),
(canvas.size[0] - bootOffset, bootY)),
fill=BLACK)
im_drawer.text(xy=(canvas.size[0] - bootOffset + 10, bootY + TEXT_Y_DISPLACEMENT),
text='%2.1f' % item, font=bootScaleFont, fill=BLACK)
if self.legendChecked:
if hasattr(self.traitList[0], 'chr') and hasattr(self.traitList[0], 'mb'):
startPosY = 30
else:
startPosY = 15
smallLabelFont = ImageFont.truetype(
font=TREBUC_FILE, size=12 * fontZoom)
leftOffset = canvas.size[0] - xRightOffset - 190
im_drawer.rectangle(
xy=((leftOffset, startPosY - 6),
(leftOffset + 12, startPosY + 6)),
fill=YELLOW, outline=BLACK)
im_drawer.text(xy=(canvas.size[0] - xRightOffset - 170, startPosY + TEXT_Y_DISPLACEMENT),
text='Frequency of the Peak LRS',
font=smallLabelFont, fill=BLACK)
def drawProbeSetPosition(self, canvas, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
im_drawer = ImageDraw.Draw(canvas)
if len(self.traitList) != 1:
return
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
yZero = canvas.size[1] - yBottomOffset
fontZoom = zoom
if zoom == 2:
fontZoom = 1.5
try:
Chr = self.traitList[0].chr
Mb = self.traitList[0].mb
except:
return
previous_chr = 1
previous_chr_as_int = 0
if self.plotScale == "physic":
this_chr = str(self.ChrList[self.selectedChr][0])
else:
this_chr = str(self.ChrList[self.selectedChr][1] + 1)
if self.plotScale == 'physic':
if self.selectedChr > -1:
if this_chr != Chr or Mb < self.startMb or Mb > self.endMb:
return
else:
locPixel = xLeftOffset + (Mb - self.startMb) * plotXScale
else:
locPixel = xLeftOffset
for i, _chr in enumerate(self.ChrList[1:]):
if _chr[0] != Chr:
locPixel += (self.ChrLengthDistList[i] + \
self.GraphInterval) * plotXScale
else:
locPixel += Mb * plotXScale
break
else:
if self.selectedChr > -1:
for i, qtlresult in enumerate(self.qtlresults):
if qtlresult['chr'] != self.selectedChr:
continue
if i == 0 and qtlresult['Mb'] >= Mb:
locPixel = -1
break
# the trait's position is between two traits
if i > 0 and self.qtlresults[i - 1]['Mb'] < Mb and qtlresult['Mb'] >= Mb:
locPixel = xLeftOffset + plotXScale * (self.qtlresults[i - 1]['Mb'] + (qtlresult['Mb'] - self.qtlresults[i - 1]['Mb']) * (
Mb - self.qtlresults[i - 1]['Mb']) / (qtlresult['Mb'] - self.qtlresults[i - 1]['Mb']))
break
# the trait's position is on the right of the last genotype
if i == len(self.qtlresults) and Mb >= qtlresult['Mb']:
locPixel = -1
else:
locPixel = xLeftOffset
for i, _chr in enumerate(self.ChrList):
if i < (len(self.ChrList) - 1):
if _chr != Chr:
locPixel += (self.ChrLengthDistList[i] + \
self.GraphInterval) * plotXScale
else:
locPixel += (Mb * (_chr[-1].cM - _chr[0].cM) / \
self.ChrLengthCMList[i]) * plotXScale
break
if locPixel >= 0 and self.plotScale == 'physic':
traitPixel = ((locPixel, yZero), (locPixel - 7,
yZero + 14), (locPixel + 7, yZero + 14))
draw_open_polygon(canvas, xy=traitPixel, outline=BLACK,
fill=self.TRANSCRIPT_LOCATION_COLOR)
def drawSNPTrackNew(self, canvas, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
im_drawer = ImageDraw.Draw(canvas)
if self.plotScale != 'physic' or self.selectedChr == -1 or not self.diffCol:
return
SNP_HEIGHT_MODIFIER = 18.0
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
yZero = canvas.size[1] - yBottomOffset
fontZoom = zoom
if zoom == 2:
fontZoom = 1.5
drawSNPLocationY = yTopOffset + plotHeight
#chrName = self.genotype[0].name
chrName = self.ChrList[self.selectedChr][0]
stepMb = (endMb - startMb) / plotWidth
strainId1, strainId2 = self.diffCol
SNPCounts = []
while startMb < endMb:
with database_connection(get_setting("SQL_URI")) as conn, conn.cursor() as cursor:
# snp count
cursor.execute("SELECT COUNT(*) FROM BXDSnpPosition "
"WHERE Chr = %s AND Mb >= %s AND Mb < %s AND "
"StrainId1 = %s AND StrainId2 = %s",
(chrName, f"{startMb:2.6f}",
f"{startMb + stepMb:2.6f}", strainId1, strainId2,))
SNPCounts.append(cursor.fetchone()[0])
startMb += stepMb
if (len(SNPCounts) > 0):
maxCount = max(SNPCounts)
if maxCount > 0:
for i in range(xLeftOffset, xLeftOffset + plotWidth):
snpDensity = float(
SNPCounts[i - xLeftOffset] * SNP_HEIGHT_MODIFIER / maxCount)
im_drawer.line(
xy=((i, drawSNPLocationY + (snpDensity) * zoom),
(i, drawSNPLocationY - (snpDensity) * zoom)),
fill=self.SNP_COLOR, width=1)
def drawMultiTraitName(self, fd, canvas, gifmap, showLocusForm, offset=(40, 120, 80, 10), zoom=1):
nameWidths = []
yPaddingTop = 10
colorFont = ImageFont.truetype(font=TREBUC_FILE, size=12)
if len(self.qtlresults) > 20 and self.selectedChr > -1:
rightShift = 20
rightShiftStep = 60
rectWidth = 10
else:
rightShift = 40
rightShiftStep = 80
rectWidth = 15
for k, thisTrait in enumerate(self.traitList):
thisLRSColor = self.colorCollection[k]
kstep = k % 4
if k != 0 and kstep == 0:
if nameWidths:
rightShiftStep = max(nameWidths[-4:]) + rectWidth + 20
rightShift += rightShiftStep
name = thisTrait.displayName()
nameWidth, nameHeight = im_drawer.textsize(name, font=colorFont)
nameWidths.append(nameWidth)
im_drawer.rectangle(
xy=((rightShift, yPaddingTop + kstep * 15),
(rectWidth + rightShift, yPaddingTop + 10 + kstep * 15)),
fill=thisLRSColor, outline=BLACK)
im_drawer.text(
text=name, xy=(rectWidth + 2 + rightShift,
yPaddingTop + 10 + kstep * 15),
font=colorFont, fill=BLACK)
if thisTrait.db:
COORDS = "%d,%d,%d,%d" % (rectWidth + 2 + rightShift, yPaddingTop + kstep * \
15, rectWidth + 2 + rightShift + nameWidth, yPaddingTop + 10 + kstep * 15,)
HREF = "javascript:showDatabase3('%s','%s','%s','');" % (
showLocusForm, thisTrait.db.name, thisTrait.name)
Areas = HtmlGenWrapper.create_area_tag(
shape='rect', coords=COORDS, href=HREF)
gifmap.append(Areas) # TODO
def drawLegendPanel(self, canvas, offset=(40, 120, 80, 10), zoom=1):
im_drawer = ImageDraw.Draw(canvas)
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
yZero = canvas.size[1] - yBottomOffset
TEXT_Y_DISPLACEMENT = -8
fontZoom = zoom
if zoom == 2:
fontZoom = 1.5
labelFont = ImageFont.truetype(font=TREBUC_FILE, size=12 * fontZoom)
startPosY = 15
stepPosY = 12 * fontZoom
startPosX = canvas.size[0] - xRightOffset - 415
if hasattr(self.traitList[0], 'chr') and hasattr(self.traitList[0], 'mb'):
startPosY = 15
nCol = 2
smallLabelFont = ImageFont.truetype(
font=TREBUC_FILE, size=12 * fontZoom)
leftOffset = canvas.size[0] - xRightOffset - 190
draw_open_polygon(
canvas,
xy=(
(leftOffset + 6, startPosY - 7),
(leftOffset - 1, startPosY + 7),
(leftOffset + 13, startPosY + 7)),
outline=BLACK, fill=self.TRANSCRIPT_LOCATION_COLOR
)
TEXT_Y_DISPLACEMENT = -8
im_drawer.text(
text="Gene Location",
xy=(leftOffset + 20, startPosY + TEXT_Y_DISPLACEMENT), font=smallLabelFont,
fill=self.TOP_RIGHT_INFO_COLOR)
if self.manhattan_plot != True:
im_drawer.line(
xy=((startPosX, startPosY), (startPosX + 32, startPosY)),
fill=self.LRS_COLOR, width=2)
im_drawer.text(
text=self.LRS_LOD, xy=(
startPosX + 40, startPosY + TEXT_Y_DISPLACEMENT),
font=labelFont, fill=BLACK)
startPosY += stepPosY
if self.additiveChecked:
im_drawer.line(
xy=((startPosX, startPosY), (startPosX + 17, startPosY)),
fill=self.ADDITIVE_COLOR_POSITIVE, width=2)
im_drawer.line(
xy=((startPosX + 18, startPosY), (startPosX + 32, startPosY)),
fill=self.ADDITIVE_COLOR_NEGATIVE, width=2)
im_drawer.text(
text='Additive Effect', xy=(startPosX + 40, startPosY + TEXT_Y_DISPLACEMENT),
font=labelFont, fill=BLACK)
startPosY += stepPosY
if self.genotype.type == 'intercross' and self.dominanceChecked:
im_drawer.line(
xy=((startPosX, startPosY), (startPosX + 17, startPosY)),
fill=self.DOMINANCE_COLOR_POSITIVE, width=4)
im_drawer.line(
xy=((startPosX + 18, startPosY), (startPosX + 35, startPosY)),
fill=self.DOMINANCE_COLOR_NEGATIVE, width=4)
im_drawer.text(
text='Dominance Effect', xy=(startPosX + 42, startPosY + 5),
font=labelFont, fill=BLACK)
startPosY += stepPosY
if self.haplotypeAnalystChecked:
im_drawer.line(
xy=((startPosX - 60, startPosY), (startPosX - 45, startPosY)),
fill=self.HAPLOTYPE_NEGATIVE, width=8)
im_drawer.line(
xy=((startPosX - 45, startPosY), (startPosX - 30, startPosY)),
fill=self.HAPLOTYPE_POSITIVE, width=8)
im_drawer.line(
xy=((startPosX - 30, startPosY), (startPosX - 15, startPosY)),
fill=self.HAPLOTYPE_HETEROZYGOUS, width=8)
im_drawer.line(
xy=((startPosX - 15, startPosY), (startPosX, startPosY)),
fill=self.HAPLOTYPE_RECOMBINATION, width=8)
im_drawer.text(
text='Haplotypes (Mat, Pat, Het, Unknown)',
xy=(startPosX + 10, startPosY + TEXT_Y_DISPLACEMENT), font=labelFont, fill=BLACK)
startPosY += stepPosY
if self.permChecked and self.nperm > 0:
thisStartX = startPosX
if self.multipleInterval and not self.bootChecked:
thisStartX = canvas.size[0] - xRightOffset - 205
im_drawer.line(
xy=((thisStartX, startPosY), (startPosX + 32, startPosY)),
fill=self.SIGNIFICANT_COLOR, width=self.SIGNIFICANT_WIDTH)
im_drawer.line(
xy=((thisStartX, startPosY + stepPosY),
(startPosX + 32, startPosY + stepPosY)),
fill=self.SUGGESTIVE_COLOR, width=self.SUGGESTIVE_WIDTH)
im_drawer.text(
text='Significant %s = %2.2f' % (
self.LRS_LOD, self.significant),
xy=(thisStartX + 40, startPosY + TEXT_Y_DISPLACEMENT), font=labelFont, fill=BLACK)
im_drawer.text(
text='Suggestive %s = %2.2f' % (self.LRS_LOD, self.suggestive),
xy=(thisStartX + 40, startPosY + TEXT_Y_DISPLACEMENT + stepPosY), font=labelFont,
fill=BLACK)
labelFont = ImageFont.truetype(font=VERDANA_FILE, size=12 * fontZoom)
labelColor = BLACK
if self.dataset.type == "Publish" or self.dataset.type == "Geno":
dataset_label = self.dataset.fullname
else:
dataset_label = "%s - %s" % (self.dataset.group.name,
self.dataset.fullname)
self.current_datetime = datetime.datetime.now().strftime("%b %d %Y %H:%M:%S")
string1 = 'UTC Timestamp: %s' % (self.current_datetime)
string2 = 'Dataset: %s' % (dataset_label)
string3 = 'Trait Hash: %s' % (self.vals_hash)
if self.genofile_string == "":
string4 = 'Genotype File: %s.geno' % self.dataset.group.name
else:
string4 = 'Genotype File: %s' % self.genofile_string.split(":")[1]
string6 = ''
if self.mapping_method == "gemma" or self.mapping_method == "gemma_bimbam":
if self.use_loco == "True":
string5 = 'Using GEMMA mapping method with LOCO and '
else:
string5 = 'Using GEMMA mapping method with '
if self.covariates != "":
string5 += 'the cofactors below:'
cofactor_names = ", ".join(
[covar.split(":")[0] for covar in self.covariates.split(",")])
string6 = cofactor_names
else:
string5 += 'no cofactors'
elif self.mapping_method == "rqtl_plink" or self.mapping_method == "rqtl_geno":
string5 = 'Using R/qtl mapping method with '
if self.covariates != "":
string5 += 'the cofactors below:'
cofactor_names = ", ".join(
[covar.split(":")[0] for covar in self.covariates.split(",")])
string6 = cofactor_names
elif self.controlLocus and self.doControl != "false":
string5 += '%s as control' % self.controlLocus
else:
string5 += 'no cofactors'
else:
string5 = 'Using Haldane mapping function with '
if self.controlLocus and self.doControl != "false":
string5 += '%s as control' % self.controlLocus
else:
string5 += 'no control for other QTLs'
y_constant = 10
if self.this_trait.name:
if self.selectedChr == -1:
identification = "Mapping on All Chromosomes for "
else:
identification = "Mapping on Chromosome %s for " % (
self.ChrList[self.selectedChr][0])
if self.this_trait.symbol:
identification += "Trait: %s - %s" % (
self.this_trait.display_name, self.this_trait.symbol)
elif self.dataset.type == "Publish":
if self.this_trait.post_publication_abbreviation:
identification += "Trait: %s - %s" % (
self.this_trait.display_name, self.this_trait.post_publication_abbreviation)
elif self.this_trait.pre_publication_abbreviation:
identification += "Trait: %s - %s" % (
self.this_trait.display_name, self.this_trait.pre_publication_abbreviation)
else:
identification += "Trait: %s" % (self.this_trait.display_name)
else:
identification += "Trait: %s" % (self.this_trait.display_name)
identification += " with %s samples" % (self.n_samples)
d = 4 + max(
im_drawer.textsize(identification, font=labelFont)[0],
im_drawer.textsize(string1, font=labelFont)[0],
im_drawer.textsize(string2, font=labelFont)[0],
im_drawer.textsize(string3, font=labelFont)[0],
im_drawer.textsize(string4, font=labelFont)[0])
im_drawer.text(
text=identification,
xy=(xLeftOffset, y_constant * fontZoom), font=labelFont,
fill=labelColor)
y_constant += 15
else:
d = 4 + max(
im_drawer.textsize(string1, font=labelFont)[0],
im_drawer.textsize(string2, font=labelFont)[0],
im_drawer.textsize(string3, font=labelFont)[0],
im_drawer.textsize(string4, font=labelFont)[0])
if len(self.transform) > 0:
transform_text = "Transform - "
if self.transform == "qnorm":
transform_text += "Quantile Normalized"
elif self.transform == "log2" or self.transform == "log10":
transform_text += self.transform.capitalize()
elif self.transform == "sqrt":
transform_text += "Square Root"
elif self.transform == "zscore":
transform_text += "Z-Score"
elif self.transform == "invert":
transform_text += "Invert +/-"
im_drawer.text(
text=transform_text, xy=(xLeftOffset, y_constant * fontZoom),
font=labelFont, fill=labelColor)
y_constant += 15
im_drawer.text(
text=string1, xy=(xLeftOffset, y_constant * fontZoom),
font=labelFont, fill=labelColor)
y_constant += 15
im_drawer.text(
text=string2, xy=(xLeftOffset, y_constant * fontZoom),
font=labelFont, fill=labelColor)
y_constant += 15
im_drawer.text(
text=string3, xy=(xLeftOffset, y_constant * fontZoom),
font=labelFont, fill=labelColor)
y_constant += 15
im_drawer.text(
text=string4, xy=(xLeftOffset, y_constant * fontZoom),
font=labelFont, fill=labelColor)
y_constant += 15
if string4 != '':
im_drawer.text(
text=string5, xy=(xLeftOffset, y_constant * fontZoom),
font=labelFont, fill=labelColor)
y_constant += 15
if string5 != '':
im_drawer.text(
text=string6, xy=(xLeftOffset, y_constant * fontZoom),
font=labelFont, fill=labelColor)
def drawHomologyBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
im_drawer = ImageDraw.Draw(canvas)
if self.plotScale != 'physic' or self.selectedChr == -1 or not self.homology:
return
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
yZero = canvas.size[1] - yBottomOffset
fontZoom = zoom
if zoom == 2:
fontZoom = 1.5
yPaddingTop = yTopOffset
for index, homology_dict in enumerate(self.homology):
ref_strand = homology_dict["ref_strand"]
ref_start = homology_dict["ref_start"]
ref_end = homology_dict["ref_end"]
query_chr = homology_dict["query_chr"]
query_strand = homology_dict["query_strand"]
query_start = homology_dict["query_start"]
query_end = homology_dict["query_end"]
geneLength = (ref_end - ref_start) * 1000.0
tenPercentLength = geneLength * 0.0001
geneStartPix = xLeftOffset + \
plotXScale * (float(ref_start) - startMb)
geneEndPix = xLeftOffset + plotXScale * \
(float(ref_end) - startMb) # at least one pixel
if (geneEndPix < xLeftOffset):
return # this gene is not on the screen
if (geneEndPix > xLeftOffset + plotWidth):
geneEndPix = xLeftOffset + plotWidth # clip the last in-range gene
if (geneStartPix > xLeftOffset + plotWidth):
return # we are outside the valid on-screen range, so stop drawing genes
elif (geneStartPix < xLeftOffset):
geneStartPix = xLeftOffset # clip the first in-range gene
myColor = BLACK
outlineColor = myColor
fillColor = myColor
TITLE = f"hg38: Chr {query_chr} from {query_start:.3f} to {query_end:.3f} Mb"
HREF = f"http://genome.ucsc.edu/cgi-bin/hgTracks?db=hg38&position=chr{query_chr}:{int(query_start * 1000000)}-{int(query_end * 1000000)}"
# Draw Genes
geneYLocation = yPaddingTop + \
(index % self.NUM_GENE_ROWS) * self.EACH_GENE_HEIGHT * zoom
if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
geneYLocation += 4 * self.BAND_HEIGHT + 4 * self.BAND_SPACING
else:
geneYLocation += 3 * self.BAND_HEIGHT + 3 * self.BAND_SPACING
# draw the detail view
utrColor = ImageColor.getrgb("rgb(66%, 66%, 66%)")
arrowColor = ImageColor.getrgb("rgb(70%, 70%, 70%)")
# draw the line that runs the entire length of the gene
im_drawer.line(
xy=(
(geneStartPix, geneYLocation + \
self.EACH_GENE_HEIGHT / 2 * zoom),
(geneEndPix, geneYLocation + self.EACH_GENE_HEIGHT / 2 * zoom)),
fill=outlineColor, width=1)
# draw the arrows
if geneEndPix - geneStartPix < 1:
genePixRange = 1
else:
genePixRange = int(geneEndPix - geneStartPix)
for xCoord in range(0, genePixRange):
if (xCoord % self.EACH_GENE_ARROW_SPACING == 0 and xCoord + self.EACH_GENE_ARROW_SPACING < geneEndPix - geneStartPix) or xCoord == 0:
if query_strand == "+":
im_drawer.line(
xy=((geneStartPix + xCoord, geneYLocation),
(geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
fill=arrowColor, width=1)
im_drawer.line(
xy=((geneStartPix + xCoord,
geneYLocation + self.EACH_GENE_HEIGHT * zoom),
(geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
fill=arrowColor, width=1)
else:
im_drawer.line(
xy=((geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
geneYLocation),
(geneStartPix + xCoord,
geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
fill=arrowColor, width=1)
im_drawer.line(
xy=((geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
geneYLocation + self.EACH_GENE_HEIGHT * zoom),
(geneStartPix + xCoord,
geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
fill=arrowColor, width=1)
COORDS = "%d, %d, %d, %d" % (
geneStartPix, geneYLocation, geneEndPix, (geneYLocation + self.EACH_GENE_HEIGHT))
gifmap.append(
HtmlGenWrapper.create_area_tag(
shape='rect',
coords=COORDS,
href=HREF,
title=TITLE,
target="_blank"))
def drawGeneBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
im_drawer = ImageDraw.Draw(canvas)
if self.plotScale != 'physic' or self.selectedChr == -1 or not self.geneCol:
return
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
yZero = canvas.size[1] - yBottomOffset
fontZoom = zoom
if zoom == 2:
fontZoom = 1.5
yPaddingTop = yTopOffset
for gIndex, theGO in enumerate(self.geneCol):
geneNCBILink = 'http://www.ncbi.nlm.nih.gov/gene?term=%s'
if self.dataset.group.species == "mouse":
exonStarts = []
exonEnds = []
txStart = theGO["TxStart"]
txEnd = theGO["TxEnd"]
geneLength = (txEnd - txStart) * 1000.0
tenPercentLength = geneLength * 0.0001
SNPdensity = theGO["snpCount"] / geneLength
if theGO['exonStarts']:
exonStarts = list(
map(float, theGO['exonStarts'].split(",")[:-1]))
exonEnds = list(map(float, theGO['exonEnds'].split(",")[:-1]))
cdsStart = theGO['cdsStart']
cdsEnd = theGO['cdsEnd']
accession = theGO['NM_ID']
geneSymbol = theGO["GeneSymbol"]
strand = theGO["Strand"]
exonCount = theGO["exonCount"]
geneStartPix = xLeftOffset + \
plotXScale * (float(txStart) - startMb)
geneEndPix = xLeftOffset + plotXScale * \
(float(txEnd) - startMb) # at least one pixel
if (geneEndPix < xLeftOffset):
return # this gene is not on the screen
elif (geneEndPix > xLeftOffset + plotWidth):
geneEndPix = xLeftOffset + plotWidth # clip the last in-range gene
if (geneStartPix > xLeftOffset + plotWidth):
return # we are outside the valid on-screen range, so stop drawing genes
elif (geneStartPix < xLeftOffset):
geneStartPix = xLeftOffset # clip the first in-range gene
# color the gene based on SNP density
# found earlier, needs to be recomputed as snps are added
# always apply colors now, even if SNP Track not checked - Zach 11/24/2010
densities = [1.0000000000000001e-05, 0.094094033555233408,
0.3306166377816987, 0.88246026851027781, 2.6690084029581951, 4.1, 61.0]
if SNPdensity < densities[0]:
myColor = BLACK
elif SNPdensity < densities[1]:
myColor = PURPLE
elif SNPdensity < densities[2]:
myColor = DARKBLUE
elif SNPdensity < densities[3]:
myColor = DARKGREEN
elif SNPdensity < densities[4]:
myColor = GOLD
elif SNPdensity < densities[5]:
myColor = DARKORANGE
else:
myColor = DARKRED
outlineColor = myColor
fillColor = myColor
TITLE = "Gene: %s (%s)\nFrom %2.3f to %2.3f Mb (%s)\nNum. exons: %d." % (
geneSymbol, accession, float(txStart), float(txEnd), strand, exonCount)
# NL: 06-02-2011 Rob required to change this link for gene related
HREF = geneNCBILink % geneSymbol
elif self.dataset.group.species == "rat":
exonStarts = []
exonEnds = []
txStart = theGO["TxStart"]
txEnd = theGO["TxEnd"]
cdsStart = theGO["TxStart"]
cdsEnd = theGO["TxEnd"]
geneSymbol = theGO["GeneSymbol"]
strand = theGO["Strand"]
exonCount = 0
geneStartPix = xLeftOffset + \
plotXScale * (float(txStart) - startMb)
geneEndPix = xLeftOffset + plotXScale * \
(float(txEnd) - startMb) # at least one pixel
if (geneEndPix < xLeftOffset):
return # this gene is not on the screen
elif (geneEndPix > xLeftOffset + plotWidth):
geneEndPix = xLeftOffset + plotWidth # clip the last in-range gene
if (geneStartPix > xLeftOffset + plotWidth):
return # we are outside the valid on-screen range, so stop drawing genes
elif (geneStartPix < xLeftOffset):
geneStartPix = xLeftOffset # clip the first in-range gene
outlineColor = DARKBLUE
fillColor = DARKBLUE
TITLE = "Gene: %s\nFrom %2.3f to %2.3f Mb (%s)" % (
geneSymbol, float(txStart), float(txEnd), strand)
# NL: 06-02-2011 Rob required to change this link for gene related
HREF = geneNCBILink % geneSymbol
else:
outlineColor = ORANGE
fillColor = ORANGE
TITLE = "Gene: %s" % geneSymbol
# Draw Genes
geneYLocation = yPaddingTop + \
(gIndex % self.NUM_GENE_ROWS) * self.EACH_GENE_HEIGHT * zoom
if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
geneYLocation += 4 * self.BAND_HEIGHT + 4 * self.BAND_SPACING
else:
geneYLocation += 3 * self.BAND_HEIGHT + 3 * self.BAND_SPACING
# draw the detail view
if self.endMb - self.startMb <= self.DRAW_DETAIL_MB and geneEndPix - geneStartPix > self.EACH_GENE_ARROW_SPACING * 3:
utrColor = ImageColor.getrgb("rgb(66%, 66%, 66%)")
arrowColor = ImageColor.getrgb("rgb(70%, 70%, 70%)")
# draw the line that runs the entire length of the gene
im_drawer.line(
xy=(
(geneStartPix, geneYLocation + \
self.EACH_GENE_HEIGHT / 2 * zoom),
(geneEndPix, geneYLocation + self.EACH_GENE_HEIGHT / 2 * zoom)),
fill=outlineColor, width=1)
# draw the arrows
if geneEndPix - geneStartPix < 1:
genePixRange = 1
else:
genePixRange = int(geneEndPix - geneStartPix)
for xCoord in range(0, genePixRange):
if (xCoord % self.EACH_GENE_ARROW_SPACING == 0 and xCoord + self.EACH_GENE_ARROW_SPACING < geneEndPix - geneStartPix) or xCoord == 0:
if strand == "+":
im_drawer.line(
xy=((geneStartPix + xCoord, geneYLocation),
(geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
fill=arrowColor, width=1)
im_drawer.line(
xy=((geneStartPix + xCoord,
geneYLocation + self.EACH_GENE_HEIGHT * zoom),
(geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
fill=arrowColor, width=1)
else:
im_drawer.line(
xy=((geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
geneYLocation),
(geneStartPix + xCoord,
geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
fill=arrowColor, width=1)
im_drawer.line(
xy=((geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
geneYLocation + self.EACH_GENE_HEIGHT * zoom),
(geneStartPix + xCoord,
geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
fill=arrowColor, width=1)
# draw the blocks for the exon regions
for i in range(0, len(exonStarts)):
exonStartPix = (
exonStarts[i] - startMb) * plotXScale + xLeftOffset
exonEndPix = (exonEnds[i] - startMb) * \
plotXScale + xLeftOffset
if (exonStartPix < xLeftOffset):
exonStartPix = xLeftOffset
if (exonEndPix < xLeftOffset):
exonEndPix = xLeftOffset
if (exonEndPix > xLeftOffset + plotWidth):
exonEndPix = xLeftOffset + plotWidth
if (exonStartPix > xLeftOffset + plotWidth):
exonStartPix = xLeftOffset + plotWidth
im_drawer.rectangle(
xy=((exonStartPix, geneYLocation),
(exonEndPix, (geneYLocation + self.EACH_GENE_HEIGHT * zoom))),
outline=outlineColor, fill=fillColor)
# draw gray blocks for 3' and 5' UTR blocks
if cdsStart and cdsEnd:
utrStartPix = (txStart - startMb) * \
plotXScale + xLeftOffset
utrEndPix = (cdsStart - startMb) * plotXScale + xLeftOffset
if (utrStartPix < xLeftOffset):
utrStartPix = xLeftOffset
if (utrEndPix < xLeftOffset):
utrEndPix = xLeftOffset
if (utrEndPix > xLeftOffset + plotWidth):
utrEndPix = xLeftOffset + plotWidth
if (utrStartPix > xLeftOffset + plotWidth):
utrStartPix = xLeftOffset + plotWidth
if self.endMb - self.startMb <= self.DRAW_UTR_LABELS_MB:
if strand == "-":
labelText = "3'"
else:
labelText = "5'"
im_drawer.text(
text=labelText,
xy=(utrStartPix - 9, geneYLocation + \
self.EACH_GENE_HEIGHT),
font=ImageFont.truetype(font=ARIAL_FILE, size=2))
# the second UTR region
utrStartPix = (cdsEnd - startMb) * plotXScale + xLeftOffset
utrEndPix = (txEnd - startMb) * plotXScale + xLeftOffset
if (utrStartPix < xLeftOffset):
utrStartPix = xLeftOffset
if (utrEndPix < xLeftOffset):
utrEndPix = xLeftOffset
if (utrEndPix > xLeftOffset + plotWidth):
utrEndPix = xLeftOffset + plotWidth
if (utrStartPix > xLeftOffset + plotWidth):
utrStartPix = xLeftOffset + plotWidth
if self.endMb - self.startMb <= self.DRAW_UTR_LABELS_MB:
if strand == "-":
labelText = "5'"
else:
labelText = "3'"
im_drawer.text(
text=labelText,
xy=(utrEndPix + 2, geneYLocation + \
self.EACH_GENE_HEIGHT),
font=ImageFont.truetype(font=ARIAL_FILE, size=2))
# draw the genes as rectangles
else:
im_drawer.rectangle(
xy=((geneStartPix, geneYLocation),
(geneEndPix, (geneYLocation + self.EACH_GENE_HEIGHT * zoom))),
outline=outlineColor, fill=fillColor)
COORDS = "%d, %d, %d, %d" % (
geneStartPix, geneYLocation, geneEndPix, (geneYLocation + self.EACH_GENE_HEIGHT))
# NL: 06-02-2011 Rob required to display NCBI info in a new window
gifmap.append(
HtmlGenWrapper.create_area_tag(
shape='rect',
coords=COORDS,
href=HREF,
title=TITLE,
target="_blank"))
# BEGIN HaplotypeAnalyst
def drawHaplotypeBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
if self.plotScale != 'physic' or self.selectedChr == -1 or not self.geneCol:
return
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
yPaddingTop = yTopOffset
thisTrait = self.this_trait
samplelist = list(self.genotype.prgy)
smd = []
for sample in self.sample_vals_dict.keys():
if self.sample_vals_dict[sample] != "x" and sample in samplelist:
temp = GeneralObject(name=sample, value=float(
self.sample_vals_dict[sample]))
smd.append(temp)
else:
continue
smd.sort(key=lambda A: A.value)
smd.reverse()
oldgeneEndPix = -1
# Initializing plotRight, error before
plotRight = xRightOffset
im_drawer = ImageDraw.Draw(canvas)
# find out PlotRight
for _chr in self.genotype:
if _chr.name == self.ChrList[self.selectedChr][0]:
for i, _locus in enumerate(_chr):
txStart = _chr[i].Mb
txEnd = _chr[i].Mb
geneStartPix = xLeftOffset + plotXScale * \
(float(txStart) - startMb) - 0
geneEndPix = xLeftOffset + plotXScale * \
(float(txEnd) - startMb) - 0
drawit = 1
if (geneStartPix < xLeftOffset):
drawit = 0
if (geneStartPix > xLeftOffset + plotWidth):
drawit = 0
if drawit == 1:
if _chr[i].name != " - ":
plotRight = geneEndPix + 4
# end find out PlotRight
firstGene = 1
lastGene = 0
# Sets the length to the length of the strain list. Beforehand, "oldgeno = self.genotype[0][i].genotype"
# was the only place it was initialized, which worked as long as the very start (startMb = None/0) wasn't being mapped.
# Now there should always be some value set for "oldgeno" - Zach 12/14/2010
oldgeno = [None] * len(self.strainlist)
for i, _chr in enumerate(self.genotype):
if _chr.name == self.ChrList[self.selectedChr][0]:
for j, _locus in enumerate(_chr):
txStart = _chr[j].Mb
txEnd = _chr[j].Mb
geneStartPix = xLeftOffset + plotXScale * \
(float(txStart) - startMb) - 0
geneEndPix = xLeftOffset + plotXScale * \
(float(txEnd) - startMb) + 0
if oldgeneEndPix >= xLeftOffset:
drawStart = oldgeneEndPix + 4
else:
drawStart = xLeftOffset + 3
drawEnd = plotRight - 9
drawit = 1
if (geneStartPix < xLeftOffset):
if firstGene == 1:
drawit = 1
else:
drawit = 0
elif (geneStartPix > (xLeftOffset + plotWidth - 3)):
if lastGene == 0:
drawit = 1
drawEnd = xLeftOffset + plotWidth - 6
lastGene = 1
else:
break
else:
firstGene = 0
drawit = 1
if drawit == 1:
myColor = DARKBLUE
outlineColor = myColor
fillColor = myColor
maxind = 0
# Draw Genes
geneYLocation = yPaddingTop
if (self.geneChecked and self.geneCol):
geneYLocation += self.NUM_GENE_ROWS * self.EACH_GENE_HEIGHT * zoom
if (self.homologyChecked and self.homology):
geneYLocation += self.NUM_GENE_ROWS * self.EACH_GENE_HEIGHT * zoom
if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
geneYLocation += 4 * self.BAND_HEIGHT + 4 * self.BAND_SPACING
else:
geneYLocation += 3 * self.BAND_HEIGHT + 3 * self.BAND_SPACING
if _chr[j].name != " - ":
if (firstGene == 1) and (lastGene != 1):
oldgeneEndPix = drawStart = xLeftOffset
oldgeno = _chr[j].genotype
continue
for k, _geno in enumerate(_chr[j].genotype):
plotbxd = 0
if samplelist[k] in [item.name for item in smd]:
plotbxd = 1
if (plotbxd == 1):
ind = 0
if samplelist[k] in [item.name for item in smd]:
ind = [item.name for item in smd].index(
samplelist[k])
maxind = max(ind, maxind)
# lines
if (oldgeno[k] == -1 and _geno == -1):
mylineColor = self.HAPLOTYPE_NEGATIVE
elif (oldgeno[k] == 1 and _geno == 1):
mylineColor = self.HAPLOTYPE_POSITIVE
elif (oldgeno[k] == 0 and _geno == 0):
mylineColor = self.HAPLOTYPE_HETEROZYGOUS
else:
mylineColor = self.HAPLOTYPE_RECOMBINATION # XZ: Unknown
im_drawer.line(
xy=((drawStart,
geneYLocation + 7 + 2 * ind * self.EACH_GENE_HEIGHT * zoom),
(drawEnd,
geneYLocation + 7 + 2 * ind * self.EACH_GENE_HEIGHT * zoom)),
fill=mylineColor, width=zoom * (self.EACH_GENE_HEIGHT + 2))
fillColor = BLACK
outlineColor = BLACK
if lastGene == 0:
im_drawer.rectangle(
xy=((geneStartPix,
geneYLocation + 2 * ind * self.EACH_GENE_HEIGHT * zoom),
(geneEndPix,
geneYLocation + 2 * ind * self.EACH_GENE_HEIGHT + 2 * self.EACH_GENE_HEIGHT * zoom)),
outline=outlineColor, fill=fillColor)
COORDS = "%d, %d, %d, %d" % (
geneStartPix, geneYLocation + ind * self.EACH_GENE_HEIGHT, geneEndPix + 1, (geneYLocation + ind * self.EACH_GENE_HEIGHT))
TITLE = "Strain: %s, marker (%s) \n Position %2.3f Mb." % (
samplelist[k], _chr[j].name, float(txStart))
HREF = ''
gifmap.append(
HtmlGenWrapper.create_area_tag(
shape='rect',
coords=COORDS,
href=HREF,
title=TITLE))
# if there are no more markers in a chromosome, the plotRight value calculated above will be before the plotWidth
# resulting in some empty space on the right side of the plot area. This draws an "unknown" bar from plotRight to the edge.
if (plotRight < (xLeftOffset + plotWidth - 3)) and (lastGene == 0):
drawEnd = xLeftOffset + plotWidth - 6
mylineColor = self.HAPLOTYPE_RECOMBINATION
im_drawer.line(
xy=((plotRight,
geneYLocation + 7 + 2 * ind * self.EACH_GENE_HEIGHT * zoom),
(drawEnd,
geneYLocation + 7 + 2 * ind * self.EACH_GENE_HEIGHT * zoom)),
fill=mylineColor, width=zoom * (self.EACH_GENE_HEIGHT + 2))
if lastGene == 0:
draw_rotated_text(
canvas, text="%s" % (_chr[j].name),
font=ImageFont.truetype(font=VERDANA_FILE,
size=12),
xy=(geneStartPix,
geneYLocation + 17 + 2 * maxind * self.EACH_GENE_HEIGHT * zoom),
fill=BLACK, angle=-90)
oldgeneEndPix = geneEndPix
oldgeno = _chr[j].genotype
firstGene = 0
else:
lastGene = 0
for i, _chr in enumerate(self.genotype):
if _chr.name == self.ChrList[self.selectedChr][0]:
for j, _geno in enumerate(_chr[1].genotype):
plotbxd = 0
if samplelist[j] in [item.name for item in smd]:
plotbxd = 1
if (plotbxd == 1):
ind = [item.name for item in smd].index(
samplelist[j]) - 1
expr = smd[ind+1].value
# Place where font is hardcoded
im_drawer.text(
text="%s" % (samplelist[j]),
xy=((xLeftOffset + plotWidth + 10),
geneYLocation + 11 + 2 * ind * self.EACH_GENE_HEIGHT * zoom),
font=ImageFont.truetype(
font=VERDANA_FILE, size=12),
fill=BLACK)
im_drawer.text(
text="%2.2f" % (expr),
xy=((xLeftOffset + plotWidth + 80),
geneYLocation + 11 + 2 * ind * self.EACH_GENE_HEIGHT * zoom),
font=ImageFont.truetype(
font=VERDANA_FILE, size=12),
fill=BLACK)
# END HaplotypeAnalyst
def drawClickBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
im_drawer = ImageDraw.Draw(canvas)
if self.plotScale != 'physic' or self.selectedChr == -1:
return
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
yZero = canvas.size[1] - yBottomOffset
fontZoom = zoom
if zoom == 2:
fontZoom = 1.5
# only draw this many clickable regions (if you set it higher, you get more precision in clicking,
# but it makes the HTML huge, and takes forever to render the page in the first place)
# Draw the bands that you can click on to go to UCSC / Ensembl
MAX_CLICKABLE_REGION_DIVISIONS = 100
clickableRegionLabelFont = ImageFont.truetype(
font=VERDANA_FILE, size=9)
pixelStep = max(
5, int(float(plotWidth) / MAX_CLICKABLE_REGION_DIVISIONS))
# pixelStep: every N pixels, we make a new clickable area for the user to go to that area of the genome.
numBasesCurrentlyOnScreen = self.kONE_MILLION * \
abs(startMb - endMb) # Number of bases on screen now
flankingWidthInBases = int(
min((float(numBasesCurrentlyOnScreen) / 2.0), (5 * self.kONE_MILLION)))
webqtlZoomWidth = numBasesCurrentlyOnScreen / 16.0
# Flanking width should be such that we either zoom in to a 10 million base region, or we show the clicked region at the same scale as we are currently seeing.
currentChromosome = self.genotype[0].name
i = 0
paddingTop = yTopOffset
phenogenPaddingTop = paddingTop + \
(self.BAND_HEIGHT + self.BAND_SPACING)
if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
ucscPaddingTop = paddingTop + 2 * \
(self.BAND_HEIGHT + self.BAND_SPACING)
ensemblPaddingTop = paddingTop + 3 * \
(self.BAND_HEIGHT + self.BAND_SPACING)
else:
ucscPaddingTop = paddingTop + \
(self.BAND_HEIGHT + self.BAND_SPACING)
ensemblPaddingTop = paddingTop + 2 * \
(self.BAND_HEIGHT + self.BAND_SPACING)
if zoom == 1:
for pixel in range(xLeftOffset, xLeftOffset + plotWidth, pixelStep):
calBase = self.kONE_MILLION * \
(startMb + (endMb - startMb) * \
(pixel - xLeftOffset - 0.0) / plotWidth)
xBrowse1 = pixel
xBrowse2 = min(xLeftOffset + plotWidth,
(pixel + pixelStep - 1))
WEBQTL_COORDS = "%d, %d, %d, %d" % (
xBrowse1, paddingTop, xBrowse2, (paddingTop + self.BAND_HEIGHT))
WEBQTL_HREF = "javascript:rangeView('%s', %f, %f)" % (self.selectedChr - 1, max(
0, (calBase - webqtlZoomWidth)) / 1000000.0, (calBase + webqtlZoomWidth) / 1000000.0)
WEBQTL_TITLE = "Click to view this section of the genome in WebQTL"
gifmap.append(
HtmlGenWrapper.create_area_tag(
shape='rect',
coords=WEBQTL_COORDS,
href=WEBQTL_HREF,
title=WEBQTL_TITLE))
im_drawer.rectangle(
xy=((xBrowse1, paddingTop),
(xBrowse2, (paddingTop + self.BAND_HEIGHT))),
outline=self.CLICKABLE_WEBQTL_REGION_COLOR,
fill=self.CLICKABLE_WEBQTL_REGION_COLOR)
im_drawer.line(
xy=((xBrowse1, paddingTop), (xBrowse1,
(paddingTop + self.BAND_HEIGHT))),
fill=self.CLICKABLE_WEBQTL_REGION_OUTLINE_COLOR)
if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
PHENOGEN_COORDS = "%d, %d, %d, %d" % (
xBrowse1, phenogenPaddingTop, xBrowse2, (phenogenPaddingTop + self.BAND_HEIGHT))
if self.dataset.group.species == "mouse":
PHENOGEN_HREF = "https://phenogen.org/gene.jsp?speciesCB=Mm&auto=Y&geneTxt=chr%s:%d-%d&genomeVer=mm10" % (
self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
else:
PHENOGEN_HREF = "https://phenogen.org/gene.jsp?speciesCB=Mm&auto=Y&geneTxt=chr%s:%d-%d&genomeVer=mm10" % (
self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
PHENOGEN_TITLE = "Click to view this section of the genome in PhenoGen"
gifmap.append(
HtmlGenWrapper.create_area_tag(
shape='rect',
coords=PHENOGEN_COORDS,
href=PHENOGEN_HREF,
title=PHENOGEN_TITLE))
im_drawer.rectangle(
xy=((xBrowse1, phenogenPaddingTop),
(xBrowse2, (phenogenPaddingTop + self.BAND_HEIGHT))),
outline=self.CLICKABLE_PHENOGEN_REGION_COLOR,
fill=self.CLICKABLE_PHENOGEN_REGION_COLOR)
im_drawer.line(
xy=((xBrowse1, phenogenPaddingTop), (xBrowse1,
(phenogenPaddingTop + self.BAND_HEIGHT))),
fill=self.CLICKABLE_PHENOGEN_REGION_OUTLINE_COLOR)
UCSC_COORDS = "%d, %d, %d, %d" % (
xBrowse1, ucscPaddingTop, xBrowse2, (ucscPaddingTop + self.BAND_HEIGHT))
if self.dataset.group.species == "mouse":
UCSC_HREF = "http://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=chr%s:%d-%d&hgt.customText=%s/snp/chr%s" % (
self._ucscDb, self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases, webqtlConfig.PORTADDR, self.selectedChr)
else:
UCSC_HREF = "http://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=chr%s:%d-%d" % (
self._ucscDb, self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
UCSC_TITLE = "Click to view this section of the genome in the UCSC Genome Browser"
gifmap.append(
HtmlGenWrapper.create_area_tag(
shape='rect',
coords=UCSC_COORDS,
href=UCSC_HREF,
title=UCSC_TITLE))
im_drawer.rectangle(
xy=((xBrowse1, ucscPaddingTop),
(xBrowse2, (ucscPaddingTop + self.BAND_HEIGHT))),
outline=self.CLICKABLE_UCSC_REGION_COLOR,
fill=self.CLICKABLE_UCSC_REGION_COLOR)
im_drawer.line(
xy=((xBrowse1, ucscPaddingTop),
(xBrowse1, (ucscPaddingTop + self.BAND_HEIGHT))),
fill=self.CLICKABLE_UCSC_REGION_OUTLINE_COLOR)
ENSEMBL_COORDS = "%d, %d, %d, %d" % (
xBrowse1, ensemblPaddingTop, xBrowse2, (ensemblPaddingTop + self.BAND_HEIGHT))
if self.dataset.group.species == "mouse":
ENSEMBL_HREF = "http://www.ensembl.org/Mus_musculus/contigview?highlight=&chr=%s&vc_start=%d&vc_end=%d&x=35&y=12" % (
self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
else:
ENSEMBL_HREF = "http://www.ensembl.org/Rattus_norvegicus/contigview?chr=%s&start=%d&end=%d" % (
self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
ENSEMBL_TITLE = "Click to view this section of the genome in the Ensembl Genome Browser"
gifmap.append(HtmlGenWrapper.create_area_tag(
shape='rect',
coords=ENSEMBL_COORDS,
href=ENSEMBL_HREF,
title=ENSEMBL_TITLE))
im_drawer.rectangle(
xy=((xBrowse1, ensemblPaddingTop),
(xBrowse2, (ensemblPaddingTop + self.BAND_HEIGHT))),
outline=self.CLICKABLE_ENSEMBL_REGION_COLOR,
fill=self.CLICKABLE_ENSEMBL_REGION_COLOR)
im_drawer.line(
xy=((xBrowse1, ensemblPaddingTop),
(xBrowse1, (ensemblPaddingTop + self.BAND_HEIGHT))),
fill=self.CLICKABLE_ENSEMBL_REGION_OUTLINE_COLOR)
# end for
im_drawer.text(
text="Click to view the corresponding section of the genome in an 8x expanded WebQTL map",
xy=((xLeftOffset + 10), paddingTop), # + self.BAND_HEIGHT/2),
font=clickableRegionLabelFont,
fill=self.CLICKABLE_WEBQTL_TEXT_COLOR)
if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
im_drawer.text(
text="Click to view the corresponding section of the genome in PhenoGen",
# + self.BAND_HEIGHT/2),
xy=((xLeftOffset + 10), phenogenPaddingTop),
font=clickableRegionLabelFont, fill=self.CLICKABLE_PHENOGEN_TEXT_COLOR)
im_drawer.text(
text="Click to view the corresponding section of the genome in the UCSC Genome Browser",
# + self.BAND_HEIGHT/2),
xy=((xLeftOffset + 10), ucscPaddingTop),
font=clickableRegionLabelFont, fill=self.CLICKABLE_UCSC_TEXT_COLOR)
im_drawer.text(
text="Click to view the corresponding section of the genome in the Ensembl Genome Browser",
# + self.BAND_HEIGHT/2),
xy=((xLeftOffset + 10), ensemblPaddingTop),
font=clickableRegionLabelFont, fill=self.CLICKABLE_ENSEMBL_TEXT_COLOR)
# draw the gray text
chrFont = ImageFont.truetype(
font=VERDANA_BOLD_FILE, size=26 * zoom)
chrX = xLeftOffset + plotWidth - 2 - im_drawer.textsize(
"Chr %s" % self.ChrList[self.selectedChr][0], font=chrFont)[0]
im_drawer.text(
text="Chr %s" % self.ChrList[self.selectedChr][0],
xy=(chrX, paddingTop), font=chrFont, fill=GRAY)
# end of drawBrowserClickableRegions
else:
# draw the gray text
chrFont = ImageFont.truetype(font=VERDANA_FILE, size=26 * zoom)
chrX = xLeftOffset + (plotWidth - im_drawer.textsize(
"Chr %s" % currentChromosome, font=chrFont)[0]) / 2
im_drawer.text(
text="Chr %s" % currentChromosome, xy=(chrX, 32), font=chrFont,
fill=GRAY)
# end of drawBrowserClickableRegions
pass
def drawXAxis(self, canvas, drawAreaHeight, gifmap, plotXScale, showLocusForm, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
im_drawer = ImageDraw.Draw(canvas)
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
yZero = canvas.size[1] - yBottomOffset
fontZoom = zoom
if zoom == 2:
fontZoom = 1.5
# Parameters
NUM_MINOR_TICKS = 5 # Number of minor ticks between major ticks
X_MAJOR_TICK_THICKNESS = 3
X_MINOR_TICK_THICKNESS = 1
X_AXIS_THICKNESS = 1 * zoom
# ======= Alex: Draw the X-axis labels (megabase location)
MBLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=15 * zoom)
xMajorTickHeight = 10 * zoom # How high the tick extends below the axis
xMinorTickHeight = 5 * zoom
xAxisTickMarkColor = BLACK
xAxisLabelColor = BLACK
fontHeight = 12 * fontZoom # How tall the font that we're using is
spacingFromLabelToAxis = 10
if self.plotScale == 'physic':
strYLoc = yZero + MBLabelFont.font.height / 2
# Physical single chromosome view
if self.selectedChr > -1:
XScale = Plot.detScale(startMb, endMb)
XStart, XEnd, XStep = XScale
if XStep < 8:
XStep *= 2
spacingAmtX = spacingAmt = (XEnd - XStart) / XStep
j = 0
while abs(spacingAmtX - int(spacingAmtX)) >= spacingAmtX / 100.0 and j < 6:
j += 1
spacingAmtX *= 10
formatStr = '%%2.%df' % j
for counter, _Mb in enumerate(Plot.frange(XStart, XEnd, spacingAmt / NUM_MINOR_TICKS)):
if _Mb < startMb or _Mb > endMb:
continue
Xc = xLeftOffset + plotXScale * (_Mb - startMb)
if counter % NUM_MINOR_TICKS == 0: # Draw a MAJOR mark, not just a minor tick mark
im_drawer.line(xy=((Xc, yZero),
(Xc, yZero + xMajorTickHeight)),
fill=xAxisTickMarkColor,
width=X_MAJOR_TICK_THICKNESS) # Draw the MAJOR tick mark
# What Mbase location to put on the label
labelStr = str(formatStr % _Mb)
strWidth, strHeight = im_drawer.textsize(
labelStr, font=MBLabelFont)
drawStringXc = (Xc - (strWidth / 2.0))
im_drawer.text(xy=(drawStringXc, strYLoc),
text=labelStr, font=MBLabelFont,
fill=xAxisLabelColor)
else:
im_drawer.line(xy=((Xc, yZero),
(Xc, yZero + xMinorTickHeight)),
fill=xAxisTickMarkColor,
width=X_MINOR_TICK_THICKNESS) # Draw the MINOR tick mark
# Physical genome wide view
else:
distScale = 0
startPosX = xLeftOffset
for i, distLen in enumerate(self.ChrLengthDistList):
if distScale == 0: # universal scale in whole genome mapping
if distLen > 75:
distScale = 25
elif distLen > 30:
distScale = 10
else:
distScale = 5
for j, tickdists in enumerate(range(distScale, int(ceil(distLen)), distScale)):
im_drawer.line(
xy=((startPosX + tickdists * plotXScale, yZero),
(startPosX + tickdists * plotXScale, yZero + 7)),
fill=BLACK, width=1 * zoom)
if j % 2 == 0:
draw_rotated_text(
canvas, text=str(tickdists), font=MBLabelFont,
xy=(startPosX + tickdists * plotXScale,
yZero + 10 * zoom), fill=BLACK, angle=270)
startPosX += (self.ChrLengthDistList[i] + \
self.GraphInterval) * plotXScale
megabaseLabelFont = ImageFont.truetype(
font=VERDANA_FILE, size=int(18 * zoom * 1.5))
im_drawer.text(
text="Megabases",
xy=(
xLeftOffset + (plotWidth - im_drawer.textsize(
"Megabases", font=megabaseLabelFont)[0]) / 2,
strYLoc + MBLabelFont.font.height + 10 * (zoom % 2)),
font=megabaseLabelFont, fill=BLACK)
pass
else:
strYLoc = yZero + spacingFromLabelToAxis + MBLabelFont.font.height / 2
ChrAInfo = []
preLpos = -1
distinctCount = 0.0
if self.selectedChr == -1: # ZS: If viewing full genome/all chromosomes
for i, _chr in enumerate(self.genotype):
thisChr = []
Locus0CM = _chr[0].cM
nLoci = len(_chr)
if nLoci <= 8:
for _locus in _chr:
if _locus.name != ' - ':
if _locus.cM != preLpos:
distinctCount += 1
preLpos = _locus.cM
thisChr.append(
[_locus.name, _locus.cM - Locus0CM])
else:
for j in (0, round(nLoci / 4), round(nLoci / 2), round(nLoci * 3 / 4), -1):
while _chr[j].name == ' - ':
j += 1
if _chr[j].cM != preLpos:
distinctCount += 1
preLpos = _chr[j].cM
thisChr.append(
[_chr[j].name, _chr[j].cM - Locus0CM])
ChrAInfo.append(thisChr)
else:
for i, _chr in enumerate(self.genotype):
if _chr.name == self.ChrList[self.selectedChr][0]:
thisChr = []
Locus0CM = _chr[0].cM
for _locus in _chr:
if _locus.name != ' - ':
if _locus.cM != preLpos:
distinctCount += 1
preLpos = _locus.cM
thisChr.append(
[_locus.name, _locus.cM - Locus0CM])
ChrAInfo.append(thisChr)
stepA = (plotWidth + 0.0) / distinctCount
LRectWidth = 10
LRectHeight = 3
offsetA = -stepA
lineColor = LIGHTBLUE
startPosX = xLeftOffset
for j, ChrInfo in enumerate(ChrAInfo):
preLpos = -1
for i, item in enumerate(ChrInfo):
Lname, Lpos = item
if Lpos != preLpos:
offsetA += stepA
differ = 1
else:
differ = 0
preLpos = Lpos
Lpos *= plotXScale
if self.selectedChr > -1:
Zorder = i % 5
else:
Zorder = 0
if differ:
im_drawer.line(
xy=((startPosX + Lpos, yZero), (xLeftOffset + offsetA,\
yZero + 25)),
fill=lineColor)
im_drawer.line(
xy=((xLeftOffset + offsetA, yZero + 25), (xLeftOffset + offsetA,\
yZero + 40 + Zorder * (LRectWidth + 3))),
fill=lineColor)
rectColor = ORANGE
else:
im_drawer.line(
xy=((xLeftOffset + offsetA, yZero + 40 + Zorder * (LRectWidth + 3) - 3), (\
xLeftOffset + offsetA, yZero + 40 + Zorder * (LRectWidth + 3))),
fill=lineColor)
rectColor = DEEPPINK
im_drawer.rectangle(
xy=((xLeftOffset + offsetA, yZero + 40 + Zorder * (LRectWidth + 3)),
(xLeftOffset + offsetA - LRectHeight,
yZero + 40 + Zorder * (LRectWidth + 3) + LRectWidth)),
outline=rectColor, fill=rectColor, width=0)
COORDS = "%d,%d,%d,%d" % (xLeftOffset + offsetA - LRectHeight, yZero + 40 + Zorder * (LRectWidth + 3),\
xLeftOffset + offsetA, yZero + 40 + Zorder * (LRectWidth + 3) + LRectWidth)
HREF = "/show_trait?trait_id=%s&dataset=%s" % (
Lname, self.dataset.group.name + "Geno")
#HREF="javascript:showDatabase3('%s','%s','%s','');" % (showLocusForm,fd.RISet+"Geno", Lname)
Areas = HtmlGenWrapper.create_area_tag(
shape='rect',
coords=COORDS,
href=HREF,
target="_blank",
title="Locus : {}".format(Lname))
gifmap.append(Areas)
# piddle bug
if j == 0:
im_drawer.line(
xy=((startPosX, yZero), (startPosX, yZero + 40)),
fill=lineColor)
startPosX += (self.ChrLengthDistList[j] + \
self.GraphInterval) * plotXScale
centimorganLabelFont = ImageFont.truetype(
font=VERDANA_FILE, size=int(18 * zoom * 1.5))
im_drawer.text(
text="Centimorgans",
xy=(xLeftOffset + (plotWidth - im_drawer.textsize(
"Centimorgans", font=centimorganLabelFont)[0]) / 2,
strYLoc + MBLabelFont.font.height + 10 * (zoom % 2)),
font=centimorganLabelFont, fill=BLACK)
im_drawer.line(xy=((xLeftOffset, yZero), (xLeftOffset + plotWidth, yZero)),
fill=BLACK, width=X_AXIS_THICKNESS) # Draw the X axis itself
def drawQTL(self, canvas, drawAreaHeight, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
im_drawer = ImageDraw.Draw(canvas)
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
fontZoom = zoom
if zoom == 2:
fontZoom = 1.5
INTERCROSS = (self.genotype.type == "intercross")
# draw the LRS scale
# We first determine whether or not we are using a sliding scale.
# If so, we need to compute the maximum LRS value to determine where the max y-value should be, and call this LRS_LOD_Max.
# LRSTop is then defined to be above the LRS_LOD_Max by enough to add one additional LRSScale increment.
# if we are using a set-scale, then we set LRSTop to be the user's value, and LRS_LOD_Max doesn't matter.
# ZS: This is a mess, but I don't know a better way to account for different mapping methods returning results in different formats + the option to change between LRS and LOD
if self.lrsMax <= 0: # sliding scale
if "lrs_value" in self.qtlresults[0]:
LRS_LOD_Max = max([result['lrs_value']
for result in self.qtlresults])
if self.LRS_LOD == "LOD" or self.LRS_LOD == "-logP":
LRS_LOD_Max = LRS_LOD_Max / self.LODFACTOR
if self.permChecked and self.nperm > 0 and not self.multipleInterval:
self.significant = min(
self.significant / self.LODFACTOR, webqtlConfig.MAXLRS)
self.suggestive = min(
self.suggestive / self.LODFACTOR, webqtlConfig.MAXLRS)
else:
if self.permChecked and self.nperm > 0 and not self.multipleInterval:
self.significant = min(
self.significant, webqtlConfig.MAXLRS)
self.suggestive = min(
self.suggestive, webqtlConfig.MAXLRS)
else:
pass
else:
LRS_LOD_Max = max([result['lod_score']
for result in self.qtlresults]) + 1
if self.LRS_LOD == "LRS":
LRS_LOD_Max = LRS_LOD_Max * self.LODFACTOR
if self.permChecked and self.nperm > 0 and not self.multipleInterval:
self.significant = min(
self.significant * self.LODFACTOR, webqtlConfig.MAXLRS)
self.suggestive = min(
self.suggestive * self.LODFACTOR, webqtlConfig.MAXLRS)
else:
if self.permChecked and self.nperm > 0 and not self.multipleInterval:
self.significant = min(
self.significant, webqtlConfig.MAXLRS)
self.suggestive = min(
self.suggestive, webqtlConfig.MAXLRS)
else:
pass
if self.permChecked and self.nperm > 0 and not self.multipleInterval:
LRS_LOD_Max = max(self.significant, LRS_LOD_Max)
# genotype trait will give infinite LRS
LRS_LOD_Max = min(LRS_LOD_Max, webqtlConfig.MAXLRS)
else:
LRS_LOD_Max = self.lrsMax
# ZS: Needed to pass to genome browser
js_data = json.loads(self.js_data)
if self.LRS_LOD == "LRS":
js_data['max_score'] = LRS_LOD_Max / 4.61
else:
js_data['max_score'] = LRS_LOD_Max
self.js_data = json.dumps(js_data)
LRSScaleFont = ImageFont.truetype(font=VERDANA_FILE, size=16 * zoom)
LRSLODFont = ImageFont.truetype(
font=VERDANA_FILE, size=int(18 * zoom * 1.5))
yZero = yTopOffset + plotHeight
LRSHeightThresh = drawAreaHeight
AdditiveHeightThresh = drawAreaHeight / 2
DominanceHeightThresh = drawAreaHeight / 2
if LRS_LOD_Max > 100:
LRSScale = 20.0
elif LRS_LOD_Max > 20:
LRSScale = 5.0
elif LRS_LOD_Max > 7.5:
LRSScale = 2.5
else:
LRSScale = 1.0
LRSAxisList = Plot.frange(LRSScale, LRS_LOD_Max, LRSScale)
# ZS: Convert to int if all axis values are whole numbers
all_int = True
for item in LRSAxisList:
if isinstance(item, int):
continue
else:
all_int = False
break
# TODO(PIL): Convert from PIL
# if all_int:
# max_lrs_width = canvas.stringWidth("%d" % LRS_LOD_Max, font=LRSScaleFont) + 40
# else:
# max_lrs_width = canvas.stringWidth("%2.1f" % LRS_LOD_Max, font=LRSScaleFont) + 30
# draw the "LRS" or "LOD" string to the left of the axis
LRSScaleFont = ImageFont.truetype(font=VERDANA_FILE, size=16 * zoom)
LRSLODFont = ImageFont.truetype(
font=VERDANA_FILE, size=int(18 * zoom * 1.5))
yZero = yTopOffset + plotHeight
# TEXT_X_DISPLACEMENT = -20
#TEXT_Y_DISPLACEMENT = -215
if all_int:
TEXT_X_DISPLACEMENT = -12
else:
TEXT_X_DISPLACEMENT = -30
if self.LRS_LOD == "-logP":
TEXT_Y_DISPLACEMENT = -242
else:
TEXT_Y_DISPLACEMENT = -210
draw_rotated_text(
canvas, text=self.LRS_LOD, font=LRSLODFont,
xy=(xLeftOffset - im_drawer.textsize(
"999.99", font=LRSScaleFont)[0] - 15 * (zoom - 1) + TEXT_X_DISPLACEMENT,
yZero + TEXT_Y_DISPLACEMENT - 300 * (zoom - 1)),
fill=BLACK, angle=90)
for item in LRSAxisList:
if LRS_LOD_Max == 0.0:
LRS_LOD_Max = 0.000001
yTopOffset + 30 * (zoom - 1)
yLRS = yZero - (item / LRS_LOD_Max) * LRSHeightThresh
im_drawer.line(xy=((xLeftOffset, yLRS), (xLeftOffset - 4, yLRS)),
fill=self.LRS_COLOR, width=1 * zoom)
if all_int:
scaleStr = "%d" % item
else:
scaleStr = "%2.1f" % item
# Draw the LRS/LOD Y axis label
TEXT_Y_DISPLACEMENT = -10
im_drawer.text(
text=scaleStr,
xy=(xLeftOffset - 4 - im_drawer.textsize(scaleStr, font=LRSScaleFont)[0] - 5,
yLRS + TEXT_Y_DISPLACEMENT),
font=LRSScaleFont, fill=self.LRS_COLOR)
if self.permChecked and self.nperm > 0 and not self.multipleInterval:
significantY = yZero - self.significant * LRSHeightThresh / LRS_LOD_Max
suggestiveY = yZero - self.suggestive * LRSHeightThresh / LRS_LOD_Max
# significantY = yZero - self.significant*LRSHeightThresh/LRSAxisList[-1]
# suggestiveY = yZero - self.suggestive*LRSHeightThresh/LRSAxisList[-1]
startPosX = xLeftOffset
# "Significant" and "Suggestive" Drawing Routine
# ======= Draw the thick lines for "Significant" and "Suggestive" ===== (crowell: I tried to make the SNPs draw over these lines, but piddle wouldn't have it...)
# ZS: I don't know if what I did here with this inner function is clever or overly complicated, but it's the only way I could think of to avoid duplicating the code inside this function
def add_suggestive_significant_lines_and_legend(start_pos_x, chr_length_dist):
rightEdge = xLeftOffset + plotWidth
im_drawer.line(
xy=((start_pos_x + self.SUGGESTIVE_WIDTH / 1.5, suggestiveY),
(rightEdge, suggestiveY)),
fill=self.SUGGESTIVE_COLOR, width=self.SUGGESTIVE_WIDTH * zoom
# ,clipX=(xLeftOffset, xLeftOffset + plotWidth-2)
)
im_drawer.line(
xy=((start_pos_x + self.SUGGESTIVE_WIDTH / 1.5, significantY),
(rightEdge, significantY)),
fill=self.SIGNIFICANT_COLOR,
width=self.SIGNIFICANT_WIDTH * zoom
# , clipX=(xLeftOffset, xLeftOffset + plotWidth-2)
)
sugg_coords = "%d, %d, %d, %d" % (
start_pos_x, suggestiveY - 2, rightEdge + 2 * zoom, suggestiveY + 2)
sig_coords = "%d, %d, %d, %d" % (
start_pos_x, significantY - 2, rightEdge + 2 * zoom, significantY + 2)
if self.LRS_LOD == 'LRS':
sugg_title = "Suggestive LRS = %0.2f" % self.suggestive
sig_title = "Significant LRS = %0.2f" % self.significant
else:
sugg_title = "Suggestive LOD = %0.2f" % (
self.suggestive / 4.61)
sig_title = "Significant LOD = %0.2f" % (
self.significant / 4.61)
Areas1 = HtmlGenWrapper.create_area_tag(
shape='rect',
coords=sugg_coords,
title=sugg_title)
Areas2 = HtmlGenWrapper.create_area_tag(
shape='rect',
coords=sig_coords,
title=sig_title)
gifmap.append(Areas1)
gifmap.append(Areas2)
start_pos_x += (chr_length_dist + \
self.GraphInterval) * plotXScale
return start_pos_x
for i, _chr in enumerate(self.genotype):
if self.selectedChr != -1:
if _chr.name == self.ChrList[self.selectedChr][0]:
startPosX = add_suggestive_significant_lines_and_legend(
startPosX, self.ChrLengthDistList[0])
break
else:
continue
else:
startPosX = add_suggestive_significant_lines_and_legend(
startPosX, self.ChrLengthDistList[i])
if self.multipleInterval:
lrsEdgeWidth = 1
else:
if self.additiveChecked:
additiveMax = max([abs(X['additive'])
for X in self.qtlresults])
lrsEdgeWidth = 3
if zoom == 2:
lrsEdgeWidth = 2 * lrsEdgeWidth
LRSCoordXY = []
AdditiveCoordXY = []
DominanceCoordXY = []
symbolFont = ImageFont.truetype(
font=FNT_BS_FILE, size=5) # ZS: For Manhattan Plot
previous_chr = 1
previous_chr_as_int = 0
lineWidth = 1
oldStartPosX = 0
startPosX = xLeftOffset
for i, qtlresult in enumerate(self.qtlresults):
m = 0
thisLRSColor = self.colorCollection[0]
if qtlresult['chr'] != previous_chr and self.selectedChr == -1:
if self.manhattan_plot != True and len(LRSCoordXY) > 1:
draw_open_polygon(canvas, xy=LRSCoordXY,
outline=thisLRSColor, width=lrsEdgeWidth)
if not self.multipleInterval and self.additiveChecked:
plusColor = self.ADDITIVE_COLOR_POSITIVE
minusColor = self.ADDITIVE_COLOR_NEGATIVE
for k, aPoint in enumerate(AdditiveCoordXY):
if k > 0:
Xc0, Yc0 = AdditiveCoordXY[k - 1]
Xc, Yc = aPoint
if (Yc0 - yZero) * (Yc - yZero) < 0:
if Xc == Xc0: # genotype , locus distance is 0
Xcm = Xc
else:
Xcm = (yZero - Yc0) / \
((Yc - Yc0) / (Xc - Xc0)) + Xc0
if Yc0 < yZero:
im_drawer.line(
xy=((Xc0, Yc0), (Xcm, yZero)),
fill=plusColor, width=lineWidth
)
im_drawer.line(
xy=((Xcm, yZero),
(Xc, yZero - (Yc - yZero))),
fill=minusColor, width=lineWidth
)
else:
im_drawer.line(
xy=((Xc0, yZero - (Yc0 - yZero)),
(Xcm, yZero)),
fill=minusColor, width=lineWidth
)
im_drawer.line(
xy=((Xcm, yZero), (Xc, Yc)),
fill=plusColor, width=lineWidth
)
elif (Yc0 - yZero) * (Yc - yZero) > 0:
if Yc < yZero:
im_drawer.line(
xy=((Xc0, Yc0), (Xc, Yc)),
fill=plusColor,
width=lineWidth
)
else:
im_drawer.line(
xy=((Xc0, yZero - (Yc0 - yZero)),
(Xc, yZero - (Yc - yZero))),
fill=minusColor, width=lineWidth
)
else:
minYc = min(Yc - yZero, Yc0 - yZero)
if minYc < 0:
im_drawer.line(
xy=((Xc0, Yc0), (Xc, Yc)),
fill=plusColor, width=lineWidth
)
else:
im_drawer.line(
xy=((Xc0, yZero - (Yc0 - yZero)),
(Xc, yZero - (Yc - yZero))),
fill=minusColor, width=lineWidth
)
LRSCoordXY = []
AdditiveCoordXY = []
previous_chr = qtlresult['chr']
previous_chr_as_int += 1
newStartPosX = (
self.ChrLengthDistList[previous_chr_as_int - 1] + self.GraphInterval) * plotXScale
if newStartPosX != oldStartPosX:
startPosX += newStartPosX
oldStartPosX = newStartPosX
# This is because the chromosome value stored in qtlresult['chr'] can be (for example) either X or 20 depending upon the mapping method/scale used
this_chr = str(self.ChrList[self.selectedChr][0])
if self.plotScale != "physic":
this_chr = str(self.ChrList[self.selectedChr][1] + 1)
if self.selectedChr == -1 or str(qtlresult['chr']) == this_chr:
if self.plotScale != "physic" and self.mapping_method == "reaper" and not self.manhattan_plot:
start_cm = self.genotype[self.selectedChr - 1][0].cM
Xc = startPosX + (qtlresult['cM'] - start_cm) * plotXScale
if hasattr(self.genotype, "filler"):
if self.genotype.filler:
if self.selectedChr != -1:
Xc = startPosX + \
(qtlresult['Mb'] - start_cm) * plotXScale
else:
Xc = startPosX + ((qtlresult['Mb'] - start_cm - startMb) * plotXScale) * (
((qtlresult['Mb'] - start_cm - startMb) * plotXScale) / ((qtlresult['Mb'] - start_cm - startMb + self.GraphInterval) * plotXScale))
else:
if self.selectedChr != -1 and qtlresult['Mb'] > endMb:
Xc = startPosX + endMb * plotXScale
else:
if qtlresult['Mb'] - startMb < 0:
continue
Xc = startPosX + (qtlresult['Mb'] - startMb) * plotXScale
# updated by NL 06-18-2011:
# fix the over limit LRS graph issue since genotype trait may give infinite LRS;
# for any lrs is over than 460(LRS max in this system), it will be reset to 460
yLRS = yZero - (item / LRS_LOD_Max) * LRSHeightThresh
if 'lrs_value' in qtlresult:
if self.LRS_LOD == "LOD" or self.LRS_LOD == "-logP":
if qtlresult['lrs_value'] > 460 or qtlresult['lrs_value'] == 'inf':
Yc = yZero - webqtlConfig.MAXLRS * \
LRSHeightThresh / \
(LRS_LOD_Max * self.LODFACTOR)
else:
Yc = yZero - \
qtlresult['lrs_value'] * LRSHeightThresh / \
(LRS_LOD_Max * self.LODFACTOR)
else:
if qtlresult['lrs_value'] > 460 or qtlresult['lrs_value'] == 'inf':
Yc = yZero - webqtlConfig.MAXLRS * LRSHeightThresh / LRS_LOD_Max
else:
Yc = yZero - \
qtlresult['lrs_value'] * \
LRSHeightThresh / LRS_LOD_Max
else:
if qtlresult['lod_score'] > 100 or qtlresult['lod_score'] == 'inf':
Yc = yZero - webqtlConfig.MAXLRS * LRSHeightThresh / LRS_LOD_Max
else:
if self.LRS_LOD == "LRS":
Yc = yZero - \
qtlresult['lod_score'] * self.LODFACTOR * \
LRSHeightThresh / LRS_LOD_Max
else:
Yc = yZero - \
qtlresult['lod_score'] * \
LRSHeightThresh / LRS_LOD_Max
if self.manhattan_plot == True:
if self.color_scheme == "single":
point_color = self.manhattan_single_color
elif self.color_scheme == "varied":
point_color = DISTINCT_COLOR_LIST[previous_chr_as_int]
else:
if self.selectedChr == -1 and (previous_chr_as_int % 2 == 1):
point_color = RED
else:
point_color = BLUE
im_drawer.text(
text="5",
xy=(
Xc - im_drawer.textsize("5",
font=symbolFont)[0] / 2 + 1,
Yc - 4),
fill=point_color, font=symbolFont)
else:
LRSCoordXY.append((Xc, Yc))
if not self.multipleInterval and self.additiveChecked:
if additiveMax == 0.0:
additiveMax = 0.000001
Yc = yZero - qtlresult['additive'] * \
AdditiveHeightThresh / additiveMax
AdditiveCoordXY.append((Xc, Yc))
if self.selectedChr != -1 and qtlresult['Mb'] > endMb and endMb != -1:
break
m += 1
if self.manhattan_plot != True and len(LRSCoordXY) > 1:
draw_open_polygon(canvas, xy=LRSCoordXY, outline=thisLRSColor,
width=lrsEdgeWidth)
if not self.multipleInterval and self.additiveChecked:
plusColor = self.ADDITIVE_COLOR_POSITIVE
minusColor = self.ADDITIVE_COLOR_NEGATIVE
for k, aPoint in enumerate(AdditiveCoordXY):
if k > 0:
Xc0, Yc0 = AdditiveCoordXY[k - 1]
Xc, Yc = aPoint
if (Yc0 - yZero) * (Yc - yZero) < 0:
if Xc == Xc0: # genotype , locus distance is 0
Xcm = Xc
else:
Xcm = (yZero - Yc0) / \
((Yc - Yc0) / (Xc - Xc0)) + Xc0
if Yc0 < yZero:
im_drawer.line(
xy=((Xc0, Yc0), (Xcm, yZero)),
fill=plusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
im_drawer.line(
xy=((Xcm, yZero), (Xc, yZero - (Yc - yZero))),
fill=minusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
else:
im_drawer.line(
xy=((Xc0, yZero - (Yc0 - yZero)),
(Xcm, yZero)),
fill=minusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
im_drawer.line(
xy=((Xcm, yZero), (Xc, Yc)),
fill=plusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
elif (Yc0 - yZero) * (Yc - yZero) > 0:
if Yc < yZero:
im_drawer.line(
xy=((Xc0, Yc0), (Xc, Yc)), fill=plusColor,
width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
else:
im_drawer.line(
xy=((Xc0, yZero - (Yc0 - yZero)),
(Xc, yZero - (Yc - yZero))),
fill=minusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
else:
minYc = min(Yc - yZero, Yc0 - yZero)
if minYc < 0:
im_drawer.line(
xy=((Xc0, Yc0), (Xc, Yc)),
fill=plusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
else:
im_drawer.line(
xy=((Xc0, yZero - (Yc0 - yZero)),
(Xc, yZero - (Yc - yZero))),
fill=minusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
if not self.multipleInterval and INTERCROSS and self.dominanceChecked:
plusColor = self.DOMINANCE_COLOR_POSITIVE
minusColor = self.DOMINANCE_COLOR_NEGATIVE
for k, aPoint in enumerate(DominanceCoordXY):
if k > 0:
Xc0, Yc0 = DominanceCoordXY[k - 1]
Xc, Yc = aPoint
if (Yc0 - yZero) * (Yc - yZero) < 0:
if Xc == Xc0: # genotype , locus distance is 0
Xcm = Xc
else:
Xcm = (yZero - Yc0) / \
((Yc - Yc0) / (Xc - Xc0)) + Xc0
if Yc0 < yZero:
im_drawer.line(
xy=((Xc0, Yc0), (Xcm, yZero)),
fill=plusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
im_drawer.line(
xy=((Xcm, yZero), (Xc, yZero - (Yc - yZero))),
fill=minusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
else:
im_drawer.line(
xy=((Xc0, yZero - (Yc0 - yZero)), (Xcm, yZero)),
fill=minusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
im_drawer.line(
xy=((Xcm, yZero), (Xc, Yc)),
fill=plusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
elif (Yc0 - yZero) * (Yc - yZero) > 0:
if Yc < yZero:
im_drawer.line(
xy=((Xc0, Yc0), (Xc, Yc)),
fill=plusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
else:
im_drawer.line(
xy=((Xc0, yZero - (Yc0 - yZero)),
(Xc, yZero - (Yc - yZero))),
fill=minusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
else:
minYc = min(Yc - yZero, Yc0 - yZero)
if minYc < 0:
im_drawer.line(
xy=((Xc0, Yc0), (Xc, Yc)),
fill=plusColor, width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
else:
im_drawer.line(
xy=((Xc0, yZero - (Yc0 - yZero)),
(Xc, yZero - (Yc - yZero))), fill=minusColor,
width=lineWidth
# , clipX=(xLeftOffset, xLeftOffset + plotWidth)
)
# draw additive scale
if not self.multipleInterval and self.additiveChecked:
additiveScaleFont = ImageFont.truetype(
font=VERDANA_FILE, size=16 * zoom)
additiveScale = Plot.detScaleOld(0, additiveMax)
additiveStep = (additiveScale[1] - \
additiveScale[0]) / additiveScale[2]
additiveAxisList = Plot.frange(0, additiveScale[1], additiveStep)
addPlotScale = AdditiveHeightThresh / additiveMax
TEXT_Y_DISPLACEMENT = -8
additiveAxisList.append(additiveScale[1])
for item in additiveAxisList:
additiveY = yZero - item * addPlotScale
im_drawer.line(
xy=((xLeftOffset + plotWidth, additiveY),
(xLeftOffset + 4 + plotWidth, additiveY)),
fill=self.ADDITIVE_COLOR_POSITIVE, width=1 * zoom)
scaleStr = "%2.3f" % item
im_drawer.text(
text=scaleStr,
xy=(xLeftOffset + plotWidth + 6,
additiveY + TEXT_Y_DISPLACEMENT),
font=additiveScaleFont, fill=self.ADDITIVE_COLOR_POSITIVE)
im_drawer.line(
xy=((xLeftOffset + plotWidth, additiveY),
(xLeftOffset + plotWidth, yZero)),
fill=self.ADDITIVE_COLOR_POSITIVE, width=1 * zoom)
im_drawer.line(
xy=((xLeftOffset, yZero), (xLeftOffset, yTopOffset + 30 * (zoom - 1))),
fill=self.LRS_COLOR, width=1 * zoom) # the blue line running up the y axis
def drawGraphBackground(self, canvas, gifmap, offset=(80, 120, 80, 50), zoom=1, startMb=None, endMb=None):
# conditions
# multiple Chromosome view
# single Chromosome Physical
# single Chromosome Genetic
im_drawer = ImageDraw.Draw(canvas)
xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
yBottom = yTopOffset + plotHeight
fontZoom = zoom
if zoom == 2:
fontZoom = 1.5
yTopOffset += 30
# calculate plot scale
if self.plotScale != 'physic':
self.ChrLengthDistList = self.ChrLengthCMList
drawRegionDistance = self.ChrLengthCMSum
else:
self.ChrLengthDistList = self.ChrLengthMbList
drawRegionDistance = self.ChrLengthMbSum
if self.selectedChr > -1: # single chromosome view
spacingAmt = plotWidth / 13.5
i = 0
for startPix in Plot.frange(xLeftOffset, xLeftOffset + plotWidth, spacingAmt):
if (i % 2 == 0):
theBackColor = self.GRAPH_BACK_DARK_COLOR
else:
theBackColor = self.GRAPH_BACK_LIGHT_COLOR
i += 1
im_drawer.rectangle(
[(startPix, yTopOffset),
(min(startPix + spacingAmt, xLeftOffset + plotWidth), yBottom)],
outline=theBackColor, fill=theBackColor)
drawRegionDistance = self.ChrLengthDistList[self.ChrList[self.selectedChr][1]]
self.ChrLengthDistList = [drawRegionDistance]
if self.plotScale == 'physic':
plotXScale = plotWidth / (endMb - startMb)
else:
plotXScale = plotWidth / drawRegionDistance
else: # multiple chromosome view
plotXScale = plotWidth / \
((len(self.genotype) - 1) * self.GraphInterval + drawRegionDistance)
startPosX = xLeftOffset
if fontZoom == 1.5:
chrFontZoom = 2
else:
chrFontZoom = 1
chrLabelFont = ImageFont.truetype(
font=VERDANA_FILE, size=24 * chrFontZoom)
for i, _chr in enumerate(self.genotype):
if (i % 2 == 0):
theBackColor = self.GRAPH_BACK_DARK_COLOR
else:
theBackColor = self.GRAPH_BACK_LIGHT_COLOR
# draw the shaded boxes and the sig/sug thick lines
im_drawer.rectangle(
((startPosX, yTopOffset),
(startPosX + self.ChrLengthDistList[i] * plotXScale, yBottom)),
outline=GAINSBORO,
fill=theBackColor)
chrNameWidth, chrNameHeight = im_drawer.textsize(
_chr.name, font=chrLabelFont)
chrStartPix = startPosX + \
(self.ChrLengthDistList[i] * plotXScale - chrNameWidth) / 2
chrEndPix = startPosX + \
(self.ChrLengthDistList[i] * plotXScale + chrNameWidth) / 2
TEXT_Y_DISPLACEMENT = 0
im_drawer.text(xy=(chrStartPix, yTopOffset + TEXT_Y_DISPLACEMENT),
text=_chr.name, font=chrLabelFont, fill=BLACK)
COORDS = "%d,%d,%d,%d" % (
chrStartPix, yTopOffset, chrEndPix, yTopOffset + 20)
# add by NL 09-03-2010
HREF = "javascript:chrView(%d,%s);" % (i, self.ChrLengthMbList)
Areas = HtmlGenWrapper.create_area_tag(
shape='rect',
coords=COORDS,
href=HREF)
gifmap.append(Areas)
startPosX += (self.ChrLengthDistList[i] + \
self.GraphInterval) * plotXScale
return plotXScale
def drawPermutationHistogram(self):
#########################################
# Permutation Graph
#########################################
myCanvas = Image.new("RGBA", size=(500, 300))
if 'lod_score' in self.qtlresults[0] and self.LRS_LOD == "LRS":
perm_output = [value * 4.61 for value in self.perm_output]
elif 'lod_score' not in self.qtlresults[0] and self.LRS_LOD == "LOD":
perm_output = [value / 4.61 for value in self.perm_output]
else:
perm_output = self.perm_output
filename = webqtlUtil.genRandStr("Reg_")
Plot.plotBar(myCanvas, perm_output, XLabel=self.LRS_LOD,
YLabel='Frequency', title=' Histogram of Permutation Test')
myCanvas.save("{}.gif".format(GENERATED_IMAGE_DIR + filename),
format='gif')
return filename
def geneTable(self, geneCol, refGene=None):
if self.dataset.group.species == 'mouse' or self.dataset.group.species == 'rat':
self.gene_table_header = self.getGeneTableHeaderList(refGene=None)
self.gene_table_body = self.getGeneTableBody(geneCol, refGene=None)
else:
self.gene_table_header = None
self.gene_table_body = None
def getGeneTableHeaderList(self, refGene=None):
gene_table_header_list = []
if self.dataset.group.species == "mouse":
if refGene:
gene_table_header_list = ["Index",
"Symbol",
"Mb Start",
"Length (Kb)",
"SNP Count",
"SNP Density",
"Avg Expr",
"Human Chr",
"Mb Start (hg19)",
"Literature Correlation",
"Gene Description"]
else:
gene_table_header_list = ["",
"Index",
"Symbol",
"Mb Start",
"Length (Kb)",
"SNP Count",
"SNP Density",
"Avg Expr",
"Human Chr",
"Mb Start (hg19)",
"Gene Description"]
elif self.dataset.group.species == "rat":
gene_table_header_list = ["",
"Index",
"Symbol",
"Mb Start",
"Length (Kb)",
"Avg Expr",
"Mouse Chr",
"Mb Start (mm9)",
"Human Chr",
"Mb Start (hg19)",
"Gene Description"]
return gene_table_header_list
def getGeneTableBody(self, geneCol, refGene=None):
gene_table_body = []
tableIterationsCnt = 0
if self.dataset.group.species == "mouse":
for gIndex, theGO in enumerate(geneCol):
tableIterationsCnt = tableIterationsCnt + 1
this_row = [] # container for the cells of each row
selectCheck = HtmlGenWrapper.create_input_tag(
type_="checkbox",
name="selectCheck",
value=theGO["GeneSymbol"],
Class="checkbox trait_checkbox") # checkbox for each row
geneLength = (theGO["TxEnd"] - theGO["TxStart"]) * 1000.0
tenPercentLength = geneLength * 0.0001
txStart = theGO["TxStart"]
txEnd = theGO["TxEnd"]
theGO["snpDensity"] = theGO["snpCount"] / geneLength
if self.ALEX_DEBUG_BOOL_PRINT_GENE_LIST:
geneIdString = 'http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?db=gene&cmd=Retrieve&dopt=Graphics&list_uids=%s' % theGO[
"GeneID"]
if theGO["snpCount"]:
snpString = HT.Link(
(f"http://genenetwork.org/webqtl/main.py?FormID=snpBrowser&"
f"chr={theGO['Chr']}&"
f"start={theGO['TxStart']}&"
f"end={theGO['TxEnd']}&"
f"geneName={theGO['GeneSymbol']}&"
f"s1={self.diffCol[0]}&s2=%d"),
str(theGO["snpCount"]) # The text to display
)
snpString.set_blank_target()
snpString.set_attribute("class", "normalsize")
else:
snpString = 0
mouseStartString = "http://genome.ucsc.edu/cgi-bin/hgTracks?clade=vertebrate&org=Mouse&db=mm10&position=chr" + \
theGO["Chr"] + "%3A" + str(int(theGO["TxStart"] * 1000000.0)) + "-" + str(
int(theGO["TxEnd"] * 1000000.0)) + "&pix=620&Submit=submit"
# the chromosomes for human 1 are 1qXX.XX
if 'humanGene' in theGO:
if theGO['humanGene']["TxStart"] == '':
humanStartDisplay = ""
else:
humanStartDisplay = "%0.6f" % theGO['humanGene']["TxStart"]
humanChr = theGO['humanGene']["Chr"]
humanTxStart = theGO['humanGene']["TxStart"]
humanStartString = "http://genome.ucsc.edu/cgi-bin/hgTracks?clade=vertebrate&org=Human&db=hg17&position=chr%s:%d-%d" % (
humanChr, int(1000000 * theGO['humanGene']["TxStart"]), int(1000000 * theGO['humanGene']["TxEnd"]))
else:
humanStartString = humanChr = humanStartDisplay = "--"
geneDescription = theGO["GeneDescription"]
if len(geneDescription) > 70:
geneDescription = geneDescription[:70] + "..."
if theGO["snpDensity"] < 0.000001:
snpDensityStr = "0"
else:
snpDensityStr = "%0.6f" % theGO["snpDensity"]
avgExpr = [] # theGO["avgExprVal"]
if avgExpr in ([], None):
avgExpr = "--"
else:
avgExpr = "%0.6f" % avgExpr
# If we have a referenceGene then we will show the Literature Correlation
if theGO["Chr"] == "X":
chr_as_int = 19
else:
chr_as_int = int(theGO["Chr"]) - 1
if refGene:
literatureCorrelationString = str(self.getLiteratureCorrelation(
self.cursor, refGene, theGO['GeneID']) or "N/A")
this_row = [selectCheck.__str__(),
str(tableIterationsCnt),
str(HtmlGenWrapper.create_link_tag(
geneIdString,
theGO["GeneSymbol"],
target="_blank")
),
str(HtmlGenWrapper.create_link_tag(
mouseStartString,
"{:.6f}".format(txStart),
target="_blank")
),
str(HtmlGenWrapper.create_link_tag(
"javascript:rangeView('{}', {:f}, {:f})".format(
str(chr_as_int),
txStart - tenPercentLength,
txEnd + tenPercentLength),
"{:.3f}".format(geneLength))),
snpString,
snpDensityStr,
avgExpr,
humanChr,
str(HtmlGenWrapper.create_link_tag(
humanStartString,
humanStartDisplay,
target="_blank")),
literatureCorrelationString,
geneDescription]
else:
this_row = [selectCheck.__str__(),
str(tableIterationsCnt),
str(HtmlGenWrapper.create_link_tag(
geneIdString, theGO["GeneSymbol"],
target="_blank")),
str(HtmlGenWrapper.create_link_tag(
mouseStartString,
"{:.6f}".format(txStart),
target="_blank")),
str(HtmlGenWrapper.create_link_tag(
"javascript:rangeView('{}', {:f}, {:f})".format(
str(chr_as_int),
txStart - tenPercentLength,
txEnd + tenPercentLength),
"{:.3f}".format(geneLength))),
snpString,
snpDensityStr,
avgExpr,
humanChr,
str(HtmlGenWrapper.create_link_tag(
humanStartString,
humanStartDisplay,
target="_blank")),
geneDescription]
gene_table_body.append(this_row)
elif self.dataset.group.species == 'rat':
for gIndex, theGO in enumerate(geneCol):
this_row = [] # container for the cells of each row
selectCheck = str(HtmlGenWrapper.create_input_tag(
type_="checkbox",
name="selectCheck",
Class="checkbox trait_checkbox")) # checkbox for each row
if theGO["GeneID"] != "":
geneSymbolNCBI = str(HtmlGenWrapper.create_link_tag(
"http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?db=gene&cmd=Retrieve&dopt=Graphics&list_uids={}".format(
theGO["GeneID"]),
theGO["GeneSymbol"],
Class="normalsize",
target="_blank"))
else:
geneSymbolNCBI = theGO["GeneSymbol"]
if theGO["Chr"] == "X":
chr_as_int = 20
else:
chr_as_int = int(theGO["Chr"]) - 1
geneLength = (float(theGO["TxEnd"]) - float(theGO["TxStart"]))
geneLengthURL = "javascript:rangeView('%s', %f, %f)" % (theGO["Chr"], float(
theGO["TxStart"]) - (geneLength * 0.1), float(theGO["TxEnd"]) + (geneLength * 0.1))
avgExprVal = []
if avgExprVal != "" and avgExprVal:
avgExprVal = "%0.5f" % float(avgExprVal)
else:
avgExprVal = ""
# Mouse Gene
if theGO['mouseGene']:
mouseChr = theGO['mouseGene']["Chr"]
mouseTxStart = "%0.6f" % theGO['mouseGene']["TxStart"]
else:
mouseChr = mouseTxStart = ""
# the chromosomes for human 1 are 1qXX.XX
if 'humanGene' in theGO:
humanChr = theGO['humanGene']["Chr"]
humanTxStart = "%0.6f" % theGO['humanGene']["TxStart"]
else:
humanChr = humanTxStart = ""
geneDesc = theGO["GeneDescription"]
if geneDesc == "---":
geneDesc = ""
this_row = [selectCheck.__str__(),
str(gIndex + 1),
geneSymbolNCBI,
"%0.6f" % theGO["TxStart"],
str(HtmlGenWrapper.create_link_tag(
geneLengthURL,
"{:.3f}".format(geneLength * 1000.0))),
avgExprVal,
mouseChr,
mouseTxStart,
humanChr,
humanTxStart,
geneDesc]
gene_table_body.append(this_row)
return gene_table_body
def getLiteratureCorrelation(cursor, geneId1=None, geneId2=None):
if not geneId1 or not geneId2:
return None
if geneId1 == geneId2:
return 1.0
geneId1 = str(geneId1)
geneId2 = str(geneId2)
lCorr = None
try:
query = 'SELECT Value FROM LCorrRamin3 WHERE GeneId1 = %s and GeneId2 = %s'
for x, y in [(geneId1, geneId2), (geneId2, geneId1)]:
cursor.execute(query, (x, y))
lCorr = cursor.fetchone()
if lCorr:
lCorr = lCorr[0]
break
except:
raise # lCorr = None
return lCorr
