/* vcfUi - Variant Call Format user interface controls that are shared
* between more than one CGI. */
/* Copyright (C) 2014 The Regents of the University of California
* See kent/LICENSE or http://genome.ucsc.edu/license/ for licensing information. */
#include "common.h"
#include "cheapcgi.h"
#include "errCatch.h"
#include "hCommon.h"
#include "hui.h"
#include "jsHelper.h"
#include "vcf.h"
#include "vcfUi.h"
#include "knetUdc.h"
#include "udc.h"
INLINE char *nameOrDefault(char *thisName, char *defaultVal)
/* If thisName is not a placeholder value, return it; otherwise return default. */
{
if (isNotEmpty(thisName) && !sameString(thisName, "."))
return thisName;
return defaultVal;
}
#define VCF_HAPLOSORT_DEFAULT_DESC "middle variant in viewing window"
static void vcfCfgHaplotypeCenterHiddens(char *track, char *ctrName, char *ctrChrom, int ctrPos)
/* Make hidden form inputs and button for setting the center variant for haplotype
* clustering/sorting in hgTracks. */
{
char cartVar[1024];
safef(cartVar, sizeof(cartVar), "%s.centerVariantChrom", track);
cgiMakeHiddenVar(cartVar, ctrChrom);
safef(cartVar, sizeof(cartVar), "%s.centerVariantPos", track);
char ctrPosStr[16];
safef(ctrPosStr, sizeof(ctrPosStr), "%d", ctrPos);
cgiMakeHiddenVar(cartVar, ctrPosStr);
safef(cartVar, sizeof(cartVar), "%s.centerVariantName", track);
cgiMakeHiddenVar(cartVar, ctrName);
}
char *vcfHaplotypeOrSample(struct cart *cart)
/* Return "Sample" if the current organism is uniploid (like SARS-CoV-2), "Haplotype" otherwise. */
{
// We should make a better way of determining whether the organism is diploid,
// but for now this will prevent David from being bothered by diploid terminology
// when viewing SARS-CoV-2 variants:
return sameOk(cartOptionalString(cart, "db"), "wuhCor1") ? "Sample" : "Haplotype";
}
void vcfCfgHaplotypeCenter(struct cart *cart, struct trackDb *tdb, char *track,
boolean parentLevel, struct vcfFile *vcff,
char *thisName, char *thisChrom, int thisPos, char *formName)
/* If vcff has genotype data, show status and controls for choosing the center variant
* for haplotype clustering/sorting in hgTracks. */
{
if (vcff != NULL && vcff->genotypeCount > 1)
{
printf("using ");
char *centerChrom = cartOptionalStringClosestToHome(cart, tdb, parentLevel,
"centerVariantChrom");
if (isEmpty(centerChrom))
{
// Unspecified in cart -- describe the default action
printf(VCF_HAPLOSORT_DEFAULT_DESC " as anchor.\n");
if (isNotEmpty(thisChrom))
{
// but we do have a candidate, so offer to make it the center:
puts("
");
char *hapOrSample = vcfHaplotypeOrSample(cart);
if (sameString(hapOrSample, "Sample"))
{
puts("Samples are clustered by similarity around a central variant. "
"Samples are reordered for display using the clustering tree, which is "
"drawn in the left label area.");
}
else
{
puts("If this mode is selected and genotypes are phased or homozygous, "
"then each genotype is split into two independent haplotypes. "
"These local haplotypes are clustered by similarity around a central variant. "
"Haplotypes are reordered for display using the clustering tree, which is "
"drawn in the left label area. "
"Local haplotype blocks can often be identified using this display.");
}
printf(" To anchor the sorting to a particular variant, "
"click on the variant in the genome browser, "
"and then click on the 'Use this variant' button on the next page."
"
\n");
}
}
else
{
// Describe the one specified in cart.
int centerPos = cartUsualIntClosestToHome(cart, tdb, parentLevel, "centerVariantPos",
-1);
char *centerName = cartStringClosestToHome(cart, tdb, parentLevel, "centerVariantName");
if (isNotEmpty(thisChrom))
{
// These form inputs are for either "use me" or clear:
vcfCfgHaplotypeCenterHiddens(track, thisName, thisChrom, thisPos);
// Is this variant the same as the center variant specified in cart?
if (sameString(thisChrom, centerChrom) && sameString(thisName, centerName) &&
thisPos == centerPos)
printf("this variant as anchor.\n");
else
{
// make a "use me" button
printf("%s at %s:%d as anchor.\n
\n");
}
}
else
{
// Form inputs (in case the clear button is clicked)
vcfCfgHaplotypeCenterHiddens(track, centerName, centerChrom, centerPos);
printf("%s at %s:%d as anchor.\n",
nameOrDefault(centerName, "variant"), centerChrom, centerPos+1);
}
// Make a clear button that modifies the hiddens using onClick
puts("
\n");
}
}
}
static void vcfCfgHaplotypeMethod(struct cart *cart, struct trackDb *tdb, char *track,
boolean parentLevel, struct vcfFile *vcff)
/* If vcff has genotype data, offer the option of whether to cluster or just use the order
* of genotypes in the VCF file. For clustering, show status and controls for choosing the
* center variant for haplotype clustering/sorting in hgTracks. */
{
if (vcff != NULL && vcff->genotypeCount > 1)
{
printf("
"
"%s sorting order:
\n", vcfHaplotypeOrSample(cart));
// If trackDb specifies a treeFile, offer that as an option
char *hapMethod = cartOrTdbString(cart, tdb, VCF_HAP_METHOD_VAR, VCF_DEFAULT_HAP_METHOD);
char *hapMethodTdb = trackDbSetting(tdb, VCF_HAP_METHOD_VAR);
char varName[1024];
safef(varName, sizeof(varName), "%s." VCF_HAP_METHOD_VAR, track);
if (hapMethodTdb && startsWithWord("treeFile", hapMethodTdb))
{
puts("
");
}
}
static void vcfCfgHapClusterTreeAngle(struct cart *cart, struct trackDb *tdb, char *name,
boolean parentLevel)
/* Let the user choose branch shape. */
{
// This option applies only to center-weighted clustering; don't show option when some other
// method is selected.
char *hapMethod = cartOrTdbString(cart, tdb, VCF_HAP_METHOD_VAR, VCF_DEFAULT_HAP_METHOD);
printf("
\n",
differentString(hapMethod, VCF_HAP_METHOD_CENTER_WEIGHTED) ? " style='display: none;'" : "");
printf("%s clustering tree leaf shape: \n", vcfHaplotypeOrSample(cart));
char *treeAngle = cartOrTdbString(cart, tdb, VCF_HAP_TREEANGLE_VAR, VCF_DEFAULT_HAP_TREEANGLE);
char varName[1024];
safef(varName, sizeof(varName), "%s." VCF_HAP_TREEANGLE_VAR, name);
cgiMakeRadioButton(varName, VCF_HAP_TREEANGLE_TRIANGLE,
sameString(treeAngle, VCF_HAP_TREEANGLE_TRIANGLE));
printf("draw branches whose samples are all identical as < \n");
cgiMakeRadioButton(varName, VCF_HAP_TREEANGLE_RECTANGLE,
sameString(treeAngle, VCF_HAP_TREEANGLE_RECTANGLE));
printf("draw branches whose samples are all identical as [ \n");
puts("
");
}
static void vcfCfgHapClusterHeight(struct cart *cart, struct trackDb *tdb, struct vcfFile *vcff,
char *name, boolean parentLevel)
/* Let the user specify a height for the track. */
{
if (vcff != NULL && vcff->genotypeCount > 1)
{
printf("%s sorting display height: \n", vcfHaplotypeOrSample(cart));
int cartHeight = cartOrTdbInt(cart, tdb, VCF_HAP_HEIGHT_VAR, VCF_DEFAULT_HAP_HEIGHT);
char varName[1024];
safef(varName, sizeof(varName), "%s." VCF_HAP_HEIGHT_VAR, name);
cgiMakeIntVarInRange(varName, cartHeight, "Height (in pixels) of track", 5, "4", "10000");
puts(" ");
}
}
static void vcfCfgHapCluster(struct cart *cart, struct trackDb *tdb, struct vcfFile *vcff,
char *name, boolean parentLevel)
/* Show controls for haplotype-sorting display, which only makes sense to do when
* the VCF file describes multiple genotypes. */
{
char *hapOrSample = vcfHaplotypeOrSample(cart);
printf("
%s sorting display
\n", hapOrSample);
vcfCfgHapClusterEnable(cart, tdb, name, parentLevel);
vcfCfgHaplotypeMethod(cart, tdb, name, parentLevel, vcff);
vcfCfgHapClusterTreeAngle(cart, tdb, name, parentLevel);
vcfCfgHapClusterSampleColor(cart, tdb, name, parentLevel);
vcfCfgHapClusterColor(cart, tdb, name, parentLevel);
vcfCfgHapClusterHeight(cart, tdb, vcff, name, parentLevel);
}
static void vcfCfgMinQual(struct cart *cart, struct trackDb *tdb, struct vcfFile *vcff,
char *name, boolean parentLevel)
/* If checkbox is checked, apply minimum value filter to QUAL column. */
{
char cartVar[1024];
safef(cartVar, sizeof(cartVar), "%s." VCF_APPLY_MIN_QUAL_VAR, name);
boolean applyFilter = cartOrTdbBoolean(cart, tdb, VCF_APPLY_MIN_QUAL_VAR,
VCF_DEFAULT_APPLY_MIN_QUAL);
cgiMakeCheckBox(cartVar, applyFilter);
printf("Exclude variants with Quality/confidence score (QUAL) score less than\n");
double minQual = cartOrTdbDouble(cart, tdb, VCF_MIN_QUAL_VAR, VCF_DEFAULT_MIN_QUAL);
safef(cartVar, sizeof(cartVar), "%s." VCF_MIN_QUAL_VAR, name);
cgiMakeDoubleVar(cartVar, minQual, 10);
printf(" \n");
}
static void vcfCfgFilterColumn(struct cart *cart, struct trackDb *tdb, struct vcfFile *vcff,
char *name, boolean parentLevel)
/* Show controls for filtering by value of VCF's FILTER column, which uses values defined
* in the header. */
{
int filterCount = slCount(vcff->filterDefs);
if (filterCount < 1)
return;
printf("Exclude variants with these FILTER values: \n");
char cartVar[1024];
safef(cartVar, sizeof(cartVar), "%s."VCF_EXCLUDE_FILTER_VAR, name);
if (slCount(vcff->filterDefs) > 1)
{
jsMakeCheckboxGroupSetClearButton(cartVar, TRUE);
puts(" ");
jsMakeCheckboxGroupSetClearButton(cartVar, FALSE);
}
char *values[filterCount];
char *labels[filterCount];
int i;
struct vcfInfoDef *filt;
for (i=0, filt=vcff->filterDefs; filt != NULL; i++, filt = filt->next)
{
values[i] = filt->key;
struct dyString *dy = dyStringNew(0);
dyStringAppend(dy, filt->key);
if (isNotEmpty(filt->description))
dyStringPrintf(dy, " (%s)", filt->description);
labels[i] = dyStringCannibalize(&dy);
}
struct slName *selectedValues = NULL;
if (cartListVarExistsAnyLevel(cart, tdb, FALSE, VCF_EXCLUDE_FILTER_VAR))
selectedValues = cartOptionalSlNameListClosestToHome(cart, tdb, FALSE, VCF_EXCLUDE_FILTER_VAR);
cgiMakeCheckboxGroupWithVals(cartVar, labels, values, filterCount, selectedValues, 1);
}
static void vcfCfgMinAlleleFreq(struct cart *cart, struct trackDb *tdb, struct vcfFile *vcff,
char *name, boolean parentLevel)
/* Show input for minimum allele frequency, if we can extract it from the VCF INFO column. */
{
printf("Minimum minor allele frequency (if INFO column includes AF or AC+AN):\n");
double cartMinFreq = cartOrTdbDouble(cart, tdb, VCF_MIN_ALLELE_FREQ_VAR,
VCF_DEFAULT_MIN_ALLELE_FREQ);
char varName[1024];
safef(varName, sizeof(varName), "%s." VCF_MIN_ALLELE_FREQ_VAR, name);
cgiMakeDoubleVarInRange(varName, cartMinFreq, "minor allele frequency between 0.0 and 0.5", 5,
"0.0", "0.5");
puts(" ");
}
static char *getChildSample(struct trackDb *tdb)
/* Return just the VCF sample name of the phased trio child setting */
{
char *childSampleMaybeAlias = cloneString(trackDbLocalSetting(tdb, VCF_PHASED_CHILD_SAMPLE_SETTING));
char *pt = strchr(childSampleMaybeAlias, '|');
if (pt != NULL)
*pt = '\0';
return childSampleMaybeAlias;
}
static struct slPair *vcfPhasedGetSamplesFromTdb(struct trackDb *tdb, boolean hideOtherSamples)
/* Get the different VCF Phased Trio setings out of trackDb onto a list */
{
// cloneString here because we will be munging the result if there are alternate labels
char *childSampleMaybeAlias = cloneString(trackDbLocalSetting(tdb, VCF_PHASED_CHILD_SAMPLE_SETTING));
char *parentSamplesMaybeAlias = cloneString(trackDbLocalSetting(tdb, VCF_PHASED_PARENTS_SAMPLE_SETTING));
char *samples[VCF_PHASED_MAX_OTHER_SAMPLES+1]; // for now only allow at most two parents
int numOthers = 0;
if (parentSamplesMaybeAlias && !hideOtherSamples)
{
numOthers = chopCommas(cloneString(parentSamplesMaybeAlias), samples);
if (numOthers > VCF_PHASED_MAX_OTHER_SAMPLES)
{
warn("More than %d other samples specified for phased trio", VCF_PHASED_MAX_OTHER_SAMPLES);
numOthers = VCF_PHASED_MAX_OTHER_SAMPLES;
}
// shove child into middle of array, and if there are two parents, scoot the second one to the end
int lastParentIx = VCF_PHASED_MAX_OTHER_SAMPLES - 1;
if (samples[lastParentIx] != NULL)
samples[VCF_PHASED_MAX_OTHER_SAMPLES] = cloneString(samples[lastParentIx]);
samples[lastParentIx] = cloneString(childSampleMaybeAlias);
}
else
samples[0] = cloneString(childSampleMaybeAlias);
boolean gotAlias = strchr(samples[0], '|') != NULL; // default to whatever is first
struct slPair *ret = NULL;
int i;
for (i = 0; i < numOthers+1; i++)
{
char *val = strchr(samples[i], '|');
boolean foundAlias = val != NULL;
if (val != NULL)
{
if (foundAlias != gotAlias)
errAbort("Either all samples have aliases or none.");
else
*val++ = 0;
}
char *name = samples[i];
struct slPair *temp = slPairNew(cloneString(name), cloneString(val));
slAddHead(&ret, temp);
}
slReverse(&ret);
return ret;
}
struct slPair *vcfPhasedGetSampleOrder(struct cart *cart, struct trackDb *tdb, boolean parentLevel, boolean hideOtherSamples)
/* Parse out a trio sample order from either trackDb or the cart.
* If the trackName.sortChildBelow cart variable is true, then ensure
* the vcfChildSample sample is last in the order, otherwise, use what's
* in the trackName.vcfSampleOrder cart variable. */
{
char sampleOrderVar[1024];
safef(sampleOrderVar, sizeof(sampleOrderVar), "%s.%s", tdb->track, VCF_PHASED_SAMPLE_ORDER_VAR);
char *cartOrder = cartOptionalString(cart, sampleOrderVar);
boolean childBelow = cartUsualBooleanClosestToHome(cart, tdb, parentLevel, VCF_PHASED_CHILD_BELOW_VAR, FALSE);
struct slPair *tdbOrder = vcfPhasedGetSamplesFromTdb(tdb, hideOtherSamples);
if (!hideOtherSamples)
{
// if the user used drag and drop to reorder the trios then that takes precedence
// over the childBelow checkbox
if (cartOrder != NULL)
{
struct slName *name, *fromCart = slNameListFromComma(cartOrder);
struct slPair *ret = NULL;
for (name = fromCart; name != NULL; name = name->next)
{
struct slPair *temp = slPairFind(tdbOrder, name->name);
struct slPair *toAdd = slPairNew(temp->name, temp->val);
slAddHead(&ret, toAdd);
}
slReverse(&ret);
return ret;
}
else if (childBelow)
{
char *childName = getChildSample(tdb);
struct slPair *ret = NULL, *child = NULL, *temp = NULL;
for (temp = tdbOrder; temp != NULL; temp = temp->next)
{
struct slPair *toAdd = slPairNew(temp->name, temp->val);
if (sameString(temp->name, childName))
child = toAdd;
else
slAddHead(&ret, toAdd);
}
if (child)
slAddHead(&ret, child);
slReverse(&ret);
return ret;
}
}
// we're hiding the parents OR (we unchecked the childBelow checkbox AND we didn't drag reorder)
return tdbOrder;
}
static boolean hasSampleAliases(struct trackDb *tdb)
/* Check whether trackDb has aliases for the sample names */
{
struct slPair *nameVals = vcfPhasedGetSamplesFromTdb(tdb,FALSE);
return nameVals->val != NULL;
}
static void vcfPhasedSampleSortUi(struct cart *cart, struct trackDb *tdb, struct vcfFile *vcff, char *name,
boolean parentLevel)
/* Put up the UI for sorting the samples */
{
struct dyString *sortOrder = dyStringNew(0);
struct slPair *pair, *tdbOrder = vcfPhasedGetSampleOrder(cart, tdb, parentLevel, FALSE);
if (slCount(tdbOrder) == 1) // no sorting if there are no parents
return;
char childBelowSortOrder[1024];
safef(childBelowSortOrder, sizeof(childBelowSortOrder), "%s.%s", name, VCF_PHASED_CHILD_BELOW_VAR);
boolean isBelowChecked = cartUsualBooleanClosestToHome(cart, tdb, parentLevel, VCF_PHASED_CHILD_BELOW_VAR, FALSE);
printf("Show child haplotypes below parents:\n");
cgiMakeCheckBox(childBelowSortOrder, isBelowChecked);
char *infoText = "Check this box to sort the child haplotypes below the parents, leave unchecked"
" to use the default sort order of the child in the middle. Click into each subtrack to arbitrarily"
" order the samples which overrides this setting.";
printInfoIcon(infoText);
printf(" ");
if (!parentLevel)
{
printf("or: \n");
printf("Drag to change order:\n");
printf("