void colTransform(char *column, char *input, char *addFactor, char *mulFactor, char *output)
/* colTransform - Add and/or multiply column by constant.. */
{
int col = sqlUnsigned(column) - 1;
double add = sqlDouble(addFactor);
double mul = sqlDouble(mulFactor);
struct lineFile *lf = lineFileOpen(input, TRUE);
FILE *f = mustOpen(output, "w");
char *words[512];
int wordCount;
while ((wordCount = lineFileChop(lf, words)) > 0)
{
lineFileExpectAtLeast(lf, col, wordCount);
double x = lineFileNeedDouble(lf, words, col);
int i;
for (i=0; i<wordCount; ++i)
{
if (i != 0)
fputc('\t', f);
if (i == col)
fprintf(f, "%g", x*mul+add);
else
fputs(words[i], f);
}
fputc('\n', f);
}
carefulClose(&f);
}
struct subjInfo *doubleAdvFilter(struct column *col,
struct sqlConnection *conn, struct subjInfo *list)
/* Do advanced filter on string in main table. */
{
char *minString = advFilterVal(col, "min");
char *maxString = advFilterVal(col, "max");
if (minString || maxString)
{
double min = minString ? sqlDouble(minString) : 0.0;
double max = maxString ? sqlDouble(maxString) : 0.0;
struct subjInfo *newList = NULL, *next, *si;
for (si = list; si != NULL; si = next)
{
char *cell = col->cellVal(col, si, conn);
boolean invalid = sameString(cell,".");
double val = invalid ? 0.0 : sqlDouble(cell);
freez(&cell);
next = si->next;
if (!invalid && !((minString && (val < min)) || (maxString && (val > max))))
{
slAddHead(&newList, si);
}
}
slReverse(&newList);
list = newList;
}
return list;
}
void gtexInfoStaticLoad(char **row, struct gtexInfo *ret)
/* Load a row from gtexInfo table into ret. The contents of ret will
* be replaced at the next call to this function. */
{
ret->version = row[0];
ret->releaseDate = row[1];
ret->maxScore = sqlDouble(row[2]);
ret->maxMedianScore = sqlDouble(row[3]);
}
void bwtool_sax(struct hash *options, char *favorites, char *regions, unsigned decimals, char *alpha_s, char *bigfile,
char *outputfile)
/* bwtool_sax - main for the sax symbol program */
{
struct metaBig *mb = metaBigOpen_check(bigfile, regions);
struct bed *bed;
int alpha = (alpha_s != NULL) ? sqlUnsigned(alpha_s) : 8;
unsigned itStart = sqlUnsigned((char *)hashOptionalVal(options, "iterate-start", (alpha_s != NULL) ? alpha_s : "8"));
unsigned itEnd = sqlUnsigned((char *)hashOptionalVal(options, "iterate-end", (alpha_s != NULL) ? alpha_s : "8"));
unsigned window = sqlUnsigned((char *)hashOptionalVal(options, "sax-window", "0"));
char *mean_s = (char *)hashOptionalVal(options, "mean", NULL);
char *std_s = (char *)hashOptionalVal(options, "std", NULL);
if (mb->type != isaBigWig)
errAbort("%s doesn't seem to be a bigWig", bigfile);
double mean = bigWigMean(mb->big.bbi);
double std = bigWigStd(mb->big.bbi);
if (mean_s)
mean = sqlDouble(mean_s);
if (std_s)
std = sqlDouble(std_s);
FILE *out;
boolean do_std = (hashLookup(options, "std") != NULL);
boolean do_mean = (hashLookup(options, "mean") != NULL);
boolean bed4 = (hashLookup(options, "bed4") != NULL);
boolean wig_out = (hashLookup(options, "add-wig-out") != NULL);
if (do_mean || do_std)
{
if (!do_std || !do_mean)
errAbort("if -mean is specified, -std is required, and vice versa");
else if (std <= 0)
errAbort("-std must be > 0");
}
out = mustOpen(outputfile, "w");
for (bed = mb->sections; bed != NULL; bed = bed->next)
{
/* print a header */
if ((itStart == itEnd) && !bed4)
{
if (bed == mb->sections)
fprintf(out, "# alphabet size = %d\n", alpha);
wigsax_fasta(out, mb, bed, alpha, window, mean, std);
}
else
{
if (bed == mb->sections)
fprintf(out, "# alphabet size = %d\n", alpha);
wigsax_bed4(out, mb, bed, alpha, window, mean, std, wig_out);
}
}
metaBigClose(&mb);
carefulClose(&out);
}
struct gtexInfo *gtexInfoLoad(char **row)
/* Load a gtexInfo from row fetched with select * from gtexInfo
* from database. Dispose of this with gtexInfoFree(). */
{
struct gtexInfo *ret;
AllocVar(ret);
ret->version = cloneString(row[0]);
ret->releaseDate = cloneString(row[1]);
ret->maxScore = sqlDouble(row[2]);
ret->maxMedianScore = sqlDouble(row[3]);
return ret;
}
struct peakSource *peakSourceLoadAll(char *fileName, int dimCount)
/* Read file, parse it line by line and return list of peakSources. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
int rowSize = dimCount + 6;
char *row[rowSize];
struct peakSource *sourceList = NULL, *source;
while (lineFileNextRow(lf, row, rowSize))
{
/* Allocate struct and read in fixed fields. */
AllocVar(source);
source->dataSource = cloneString(row[0]);
source->chromColIx = sqlUnsigned(row[1]);
source->startColIx = sqlUnsigned(row[2]);
source->endColIx = sqlUnsigned(row[3]);
source->scoreColIx = sqlUnsigned(row[4]);
source->normFactor = sqlDouble(row[5]);
/* Read in dimension labels. */
AllocArray(source->labels, dimCount);
int i;
for (i=0; i<dimCount; ++i)
source->labels[i] = cloneString(row[i+6]);
/* Calculate required columns. */
int minColCount = max(source->chromColIx, source->startColIx);
minColCount = max(minColCount, source->endColIx);
minColCount = max(minColCount, source->scoreColIx);
source->minColCount = minColCount + 1;
slAddHead(&sourceList, source);
}
lineFileClose(&lf);
slReverse(&sourceList);
return sourceList;
}
struct chromGraph *chromGraphListWithTable(char *fileName, char *db, char *table)
/* Read the chromGraph file and convert to the chr,chromStart format. */
{
struct sqlConnection *conn = sqlConnect(db);
struct hash *posHash = NULL;
struct lineFile *lf;
struct chromGraph *list = NULL;
char *words[2];
checkTableForFields(conn, table);
posHash = posHashFromTable(conn, table);
sqlDisconnect(&conn);
lf = lineFileOpen(fileName, TRUE);
while (lineFileRow(lf, words))
{
struct chromGraph *cg;
/* Look up ID in hash. */
struct slPair *infoFromHash = hashFindVal(posHash, words[0]);
if (!infoFromHash)
warn("%s line %d: %s not found in %s table", fileName, lf->lineIx, words[0], table);
else
{
AllocVar(cg);
cg->chrom = cloneString(infoFromHash->name);
cg->chromStart = ptToInt(infoFromHash->val);
cg->val = sqlDouble(words[1]);
slAddHead(&list, cg);
}
}
slReverse(&list);
/* Free stuff up. */
lineFileClose(&lf);
hashFreeWithVals(&posHash, slPairFree);
return list;
}
static double getSignalAt(char *table, struct bed *cluster)
/* Get (average) signal from table entries that overlap cluster */
{
struct sqlConnection *conn = hAllocConn(database);
int count = 0;
double sum = 0;
if (sqlTableExists(conn, table)) // Table might be withdrawn from data thrash
{
int rowOffset;
struct sqlResult *sr = hRangeQuery(conn, table, cluster->chrom, cluster->chromStart,
cluster->chromEnd, NULL, &rowOffset);
int signalCol = sqlFieldColumn(sr, "signalValue");
if (signalCol < 0)
internalErr();
char **row;
while ((row = sqlNextRow(sr)) != NULL)
{
count += 1;
sum += sqlDouble(row[signalCol]);
}
sqlFreeResult(&sr);
}
hFreeConn(&conn);
if (count > 0)
return sum/count;
else
return 0;
}
void peakClusterMakerAddFromSource(struct peakClusterMaker *maker, struct peakSource *source)
/* Read through data source and add items to it to rangeTrees in maker */
{
struct hash *chromHash = maker->chromHash;
struct lineFile *lf = lineFileOpen(source->dataSource, TRUE);
struct lm *lm = chromHash->lm; /* Local memory pool - share with hash */
char *row[source->minColCount];
struct peakItem *item;
char *line;
while (lineFileNextReal(lf, &line))
{
char *asciiLine = lmCloneString(lm, line);
int wordCount = chopByWhite(line, row, source->minColCount);
lineFileExpectAtLeast(lf, source->minColCount, wordCount);
char *chrom = row[source->chromColIx];
struct hashEl *hel = hashLookup(chromHash, chrom);
if (hel == NULL)
{
struct rbTree *tree = rangeTreeNewDetailed(lm, maker->stack);
hel = hashAdd(chromHash, chrom, tree);
}
struct rbTree *tree = hel->val;
lmAllocVar(lm, item);
item->chrom = hel->name;
item->chromStart = sqlUnsigned(row[source->startColIx]);
item->chromEnd = sqlUnsigned(row[source->endColIx]);
item->score = sqlDouble(row[source->scoreColIx]) * source->normFactor;
if (item->score > 1000) item->score = 1000;
item->source = source;
item->asciiLine = asciiLine;
rangeTreeAddValList(tree, item->chromStart, item->chromEnd, item);
}
lineFileClose(&lf);
}
double calcNormScoreFactor(char *fileName, int scoreCol)
/* Figure out what to multiply things by to get a nice browser score (0-1000) */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *row[scoreCol+1];
double sum = 0, sumSquares = 0;
int n = 0;
double minVal=0, maxVal=0;
int fieldCount;
while ((fieldCount = lineFileChop(lf, row)) != 0)
{
lineFileExpectAtLeast(lf, scoreCol+1, fieldCount);
double x = sqlDouble(row[scoreCol]);
if (n == 0)
minVal = maxVal = x;
if (x < minVal) minVal = x;
if (x > maxVal) maxVal = x;
sum += x;
sumSquares += x*x;
n += 1;
}
lineFileClose(&lf);
double std = calcStdFromSums(sum, sumSquares, n);
double mean = sum/n;
double highEnd = mean + std;
if (highEnd > maxVal) highEnd = maxVal;
return 1000.0/highEnd;
}
static boolean singleFilter(struct annoFilter *filter, char **row, int rowSize)
/* Apply one filter, using either filterFunc or type-based filter on column value.
* Return TRUE if isExclude and filter passes, or if !isExclude and filter fails. */
{
boolean fail = FALSE;
if (filter->filterFunc != NULL)
fail = filter->filterFunc(filter, row, rowSize);
else if (filter->op == afMatch)
fail = !wildMatch((char *)(filter->values), row[filter->columnIx]);
else if (filter->op == afNotMatch)
fail = wildMatch((char *)(filter->values), row[filter->columnIx]);
else
{
// column is a number -- integer or floating point?
enum asTypes type = filter->type;
if (asTypesIsFloating(type))
fail = annoFilterDouble(filter, sqlDouble(row[filter->columnIx]));
else if (asTypesIsInt(type))
fail = annoFilterLongLong(filter, sqlLongLong(row[filter->columnIx]));
else
errAbort("annoFilterRowFails: unexpected enum asTypes %d for numeric filter op %d",
type, filter->op);
}
if ((filter->isExclude && !fail) || (!filter->isExclude && fail))
return TRUE;
return FALSE;
}
void protFeatStaticLoad(char **row, struct protFeat *ret)
/* Load a row from protFeat table into ret. The contents of ret will
* be replaced at the next call to this function. */
{
ret->protein = row[0];
ret->start = sqlSigned(row[1]);
ret->end = sqlSigned(row[2]);
ret->feature = row[3];
ret->score = sqlDouble(row[4]);
}
struct autoTest *autoTestLoad(char **row)
/* Load a autoTest from row fetched with select * from autoTest
* from database. Dispose of this with autoTestFree(). */
{
struct autoTest *ret;
AllocVar(ret);
ret->ptCount = sqlSigned(row[5]);
ret->difCount = sqlSigned(row[7]);
ret->valCount = sqlSigned(row[10]);
ret->id = sqlUnsigned(row[0]);
safecpy(ret->shortName, sizeof(ret->shortName), row[1]);
ret->longName = cloneString(row[2]);
{
char *s = cloneString(row[3]);
sqlStringArray(s, ret->aliases, 3);
}
{
char *s = row[4];
if(s != NULL && differentString(s, ""))
ret->threeD = pointCommaIn(&s, NULL);
}
{
int sizeOne;
sqlShortDynamicArray(row[6], &ret->pts, &sizeOne);
assert(sizeOne == ret->ptCount);
}
{
int sizeOne;
sqlUbyteDynamicArray(row[8], &ret->difs, &sizeOne);
assert(sizeOne == ret->difCount);
}
sqlSignedArray(row[9], ret->xy, 2);
{
int sizeOne;
sqlStringDynamicArray(row[11], &ret->vals, &sizeOne);
assert(sizeOne == ret->valCount);
}
ret->dblVal = sqlDouble(row[12]);
ret->fltVal = sqlFloat(row[13]);
{
int sizeOne;
sqlDoubleDynamicArray(row[14], &ret->dblArray, &sizeOne);
assert(sizeOne == ret->valCount);
}
{
int sizeOne;
sqlFloatDynamicArray(row[15], &ret->fltArray, &sizeOne);
assert(sizeOne == ret->valCount);
}
return ret;
}
static void viewLimitsCompositeOverride(struct trackDb *tdb,char *name, double *retMin,
double *retMax,double *absMin, double *absMax)
/* If aquiring min/max for composite level wig cfg. Look in parents as well as self. */
{
if (isNameAtParentLevel(tdb,name))
{
char *setting = NULL;
if (absMin != NULL && absMax != NULL)
{
setting = trackDbSettingByView(tdb,MIN_LIMIT);
if (setting != NULL)
{
if (setting[0] != '\0')
*absMin = sqlDouble(setting);
}
setting = trackDbSettingByView(tdb,MAX_LIMIT);
if (setting != NULL)
{
if (setting[0] != '\0')
*absMax = sqlDouble(setting);
}
else
{
setting = trackDbSettingByView(tdb,VIEWLIMITSMAX); // Legacy
if (setting != NULL)
{
parseColonRange(setting, absMin, absMax);
}
}
}
setting = trackDbSettingByView(tdb, VIEWLIMITS);
if (setting != NULL)
{
parseColonRange(setting, retMin, retMax);
}
}
}
static struct rqlParse *rqlParseAtom(struct tokenizer *tkz)
/* Return low level (symbol or literal) */
{
char *tok = tokenizerMustHaveNext(tkz);
struct rqlParse *p;
AllocVar(p);
char c = tok[0];
if (c == '\'' || c == '"')
{
p->op = rqlOpLiteral;
p->type = rqlTypeString;
int len = strlen(tok+1);
p->val.s = cloneStringZ(tok+1, len-1);
}
else if (isalpha(c) || c == '_')
{
p->op = rqlOpSymbol;
p->type = rqlTypeString; /* String until promoted at least. */
p->val.s = cloneString(tok);
}
else if (isdigit(c))
{
p->op = rqlOpLiteral;
p->type = rqlTypeInt;
p->val.i = sqlUnsigned(tok);
if ((tok = tokenizerNext(tkz)) != NULL)
{
if (tok[0] == '.')
{
char buf[32];
tok = tokenizerMustHaveNext(tkz);
safef(buf, sizeof(buf), "%d.%s", p->val.i, tok);
p->type = rqlTypeDouble;
p->val.x = sqlDouble(buf);
}
else
tokenizerReuse(tkz);
}
}
else if (c == '(')
{
p = rqlParseExpression(tkz);
skipOverRequired(tkz, ")");
}
else
{
errAbort("Unexpected %s line %d of %s", tok, tkz->lf->lineIx, tkz->lf->fileName);
}
return p;
}
struct protFeat *protFeatLoad(char **row)
/* Load a protFeat from row fetched with select * from protFeat
* from database. Dispose of this with protFeatFree(). */
{
struct protFeat *ret;
AllocVar(ret);
ret->protein = cloneString(row[0]);
ret->start = sqlSigned(row[1]);
ret->end = sqlSigned(row[2]);
ret->feature = cloneString(row[3]);
ret->score = sqlDouble(row[4]);
return ret;
}
static void parseColonRange(char *setting, double *retMin, double *retMax)
/* Parse setting's two colon-separated numbers into ret{Min,Max}, unless setting
* is NULL or empty or retMin/retMax is NULL. errAbort if invalid format. */
{
if (isNotEmpty(setting))
{
char tmp[64]; // Intentionally small -- should be only 2 floating point #s + ':'
safecpy(tmp, sizeof(tmp), setting);
char *words[3];
if (chopByChar(tmp, ':', words, ArraySize(words)) == 2)
{
double low = sqlDouble(words[0]);
double high = sqlDouble(words[1]);
correctOrder(low, high);
if (retMin)
*retMin = low;
if (retMax)
*retMax = high;
}
else
errAbort("Can't parse colon range '%s'", setting);
}
}
void doubleCellPrint(struct column *col, struct subjInfo *si,
struct sqlConnection *conn)
/* print double value */
{
char *s = col->cellVal(col, si, conn);
char buf[256];
if (sameString(s,".")) // known bad data value
safef(buf,sizeof(buf),"%s", s);
else
safef(buf,sizeof(buf),"%.1f",sqlDouble(s));
freeMem(s);
hPrintf("<TD align=right>");
hPrintf("%s", buf);
hPrintf("</TD>");
}
void megablastInfoStaticLoad(char **row, struct megablastInfo *ret)
/* Load a row from megablastInfo table into ret. The contents of ret will
* be replaced at the next call to this function. */
{
ret->chrom = row[0];
ret->chromStart = sqlUnsigned(row[1]);
ret->chromEnd = sqlUnsigned(row[2]);
ret->name = row[3];
ret->score = sqlUnsigned(row[4]);
safecpy(ret->strand, sizeof(ret->strand), row[5]);
ret->evalue = sqlDouble(row[6]);
ret->percentident = sqlUnsigned(row[7]);
ret->fullname = row[8];
ret->taxid = sqlUnsigned(row[9]);
}
void cdsPickStaticLoad(char **row, struct cdsPick *ret)
/* Load a row from cdsPick table into ret. The contents of ret will
* be replaced at the next call to this function. */
{
ret->name = row[0];
ret->start = sqlSigned(row[1]);
ret->end = sqlSigned(row[2]);
ret->source = row[3];
ret->score = sqlDouble(row[4]);
ret->startComplete = sqlUnsigned(row[5]);
ret->endComplete = sqlUnsigned(row[6]);
ret->swissProt = row[7];
ret->uniProt = row[8];
ret->refProt = row[9];
ret->refSeq = row[10];
ret->ccds = row[11];
}
void aveNoQuartiles(char *fileName)
/* aveNoQuartiles - Compute only min,max,mean,stdDev no quartiles */
{
bits64 count = 0;
struct lineFile *lf = lineFileOpen(fileName, TRUE);
char *words[128], *word;
int wordCount;
int wordIx = col-1;
double sumData = 0.0, sumSquares = 0.0;
double minVal = DBL_MAX, maxVal = -DBL_MAX;
while ((wordCount = lineFileChop(lf, words)) > 0)
{
word = words[wordIx];
if (word[0] == '-' || isdigit(word[0]))
{
double val = sqlDouble(word);
if (minVal > val) minVal = val;
if (maxVal < val) maxVal = val;
sumData += val;
sumSquares += val * val;
++count;
}
}
if (count == 0)
errAbort("No numerical data column %d of %s", col, fileName);
double average = sumData/count;
double stdDev = calcStdFromSums(sumData, sumSquares, count);
if (tableOut)
{
printf("# min max mean N sum stddev\n");
printf("%g %g %g %llu %g %g\n",
minVal, maxVal, average, count, sumData, stdDev);
}
else
{
printf("average %f\n", average);
printf("min %f\n", minVal);
printf("max %f\n", maxVal);
printf("count %llu\n", count);
printf("total %f\n", sumData);
printf("standard deviation %f\n", stdDev);
}
}
void txgGoodEdges(char *inTxg, char *inWeights, char *asciiThreshold,
char *outType, char *outEdges)
/* txgGoodEdges - Get edges that are above a certain threshold.. */
{
struct txGraph *txgList = txGraphLoadAll(inTxg);
verbose(2, "LOaded %d txGraphs from %s\n", slCount(txgList), inTxg);
struct hash *weightHash = hashWeights(inWeights);
verbose(2, "Loaded %d weights from %s\n", weightHash->elCount, inWeights);
double threshold = sqlDouble(asciiThreshold);
verbose(2, "Threshold %f\n", threshold);
struct txGraph *txg;
FILE *f = mustOpen(outEdges, "w");
for (txg = txgList; txg != NULL; txg = txg->next)
{
verbose(2, "%s edgeCount %d\n", txg->name, txg->edgeCount);
processOneGraph(txg, weightHash, threshold, outType, f);
}
carefulClose(&f);
}
struct megablastInfo *megablastInfoLoad(char **row)
/* Load a megablastInfo from row fetched with select * from megablastInfo
* from database. Dispose of this with megablastInfoFree(). */
{
struct megablastInfo *ret;
AllocVar(ret);
ret->chrom = cloneString(row[0]);
ret->chromStart = sqlUnsigned(row[1]);
ret->chromEnd = sqlUnsigned(row[2]);
ret->name = cloneString(row[3]);
ret->score = sqlUnsigned(row[4]);
safecpy(ret->strand, sizeof(ret->strand), row[5]);
ret->evalue = sqlDouble(row[6]);
ret->percentident = sqlUnsigned(row[7]);
ret->fullname = cloneString(row[8]);
ret->taxid = sqlUnsigned(row[9]);
return ret;
}
struct subjInfo *getOrderedList(struct column *ord,
struct column *colList, struct sqlConnection *conn,
int maxCount)
/* Return sorted list of subjects. */
{
struct subjInfo *subjList = advFilterResults(colList, conn);
struct subjInfo *si;
passedFilterCount = slCount(subjList);
for (si=subjList;si;si=si->next)
{
char *s = ord->cellVal(ord, si, conn);
if (sameString(ord->type,"integer"))
{
si->sortInteger = sqlSigned(s);
freeMem(s);
}
else if (sameString(ord->type,"double"))
{
if (sameString(s,"."))
si->sortDouble = 0;
else
si->sortDouble = sqlDouble(s);
freeMem(s);
}
else
{
si->sortString = s;
}
}
slSort(&subjList, ord->sortCmp);
if (orderOn[0]=='-')
slReverse(&subjList);
/* Trim list to max number. */
si = slElementFromIx(subjList, maxCount-1);
if (si != NULL)
si->next = NULL;
return subjList;
}
void bwtool_find_thresh(struct hash *options, char *favorites, char *regions, double fill,
char *thresh_type, char *thresh_s, char *bigfile, char *tmp_dir, char *outputfile)
/* the other kind of finding, based on thresholding. */
{
boolean inverse = (hashFindVal(options, "inverse") != NULL) ? TRUE : FALSE;
enum bw_op_type op= get_bw_op_type(thresh_type, inverse);
struct metaBig *mb = metaBigOpen_check(bigfile, tmp_dir, regions);
double thresh = sqlDouble(thresh_s);
FILE *out = mustOpen(outputfile, "w");
struct bed out_bed;
struct bed *section;
for (section = mb->sections; section != NULL; section = section->next)
{
struct perBaseWig *pbwList = perBaseWigLoadContinue(mb, section->chrom, section->chromStart,
section->chromEnd);
struct perBaseWig *pbw;
int i, len;
if (pbwList)
{
out_bed.chrom = pbwList->chrom;
for (pbw = pbwList; pbw != NULL; pbw = pbw->next)
{
i = 0;
len = pbw->chromEnd - pbw->chromStart;
out_bed.chromStart = out_bed.chromEnd = 0;
while (i < len)
{
while ((i < len) && (!fit_thresh(pbw->data[i], thresh, op)))
i++;
out_bed.chromStart = i + pbw->chromStart;
while ((i < len) && (fit_thresh(pbw->data[i], thresh, op)))
i++;
out_bed.chromEnd = i + pbw->chromStart;
if (out_bed.chromEnd > out_bed.chromStart)
bedTabOutN(&out_bed, 3, out);
}
}
perBaseWigFree(&pbwList);
}
}
metaBigClose(&mb);
carefulClose(&out);
}
void txgTrim(char *inTxg, char *inWeights, char *asciiThreshold, char *outTxg)
/* txgTrim - Trim out parts of txGraph that are not of sufficient weight.. */
{
struct txGraph *txgList = txGraphLoadAll(inTxg);
verbose(2, "LOaded %d txGraphs from %s\n", slCount(txgList), inTxg);
struct hash *weightHash = hashWeights(inWeights);
verbose(2, "Loaded %d weights from %s\n", weightHash->elCount, inWeights);
double threshold = sqlDouble(asciiThreshold);
verbose(2, "Threshold %f\n", threshold);
struct txGraph *txg;
FILE *f = mustOpen(outTxg, "w");
for (txg = txgList; txg != NULL; txg = txg->next)
{
verbose(2, "%s edgeCount %d\n", txg->name, txg->edgeCount);
txGraphTrimOne(txg, weightHash, threshold);
if (txg->edgeCount > 0)
txGraphTabOut(txg, f);
}
carefulClose(&f);
}
void wigToBed(char *inWig, char *thresholdString, char *outBed)
/* wigToBed - Convert wig to bed format using a threshold. A primitive peak caller.. */
{
double threshold = sqlDouble(thresholdString);
uglyf("converting %s to %s at threshold %g\n", inWig, outBed, threshold);
struct metaWig *mw = metaWigOpen(inWig);
FILE *f = mustOpen(outBed, "w");
struct slName *chrom, *chromList = metaWigChromList(mw);
for (chrom = chromList; chrom != NULL; chrom = chrom->next)
{
verbose(2, "Processing %s\n", chrom->name);
struct lm *lm = lmInit(0);
struct bbiInterval *intervalList = metaIntervalsForChrom(mw, chrom->name, lm);
outputIntervalsOverThreshold(chrom->name, intervalList, threshold, f);
lmCleanup(&lm);
}
metaWigClose(&mw);
carefulClose(&f);
}
struct cdsPick *cdsPickLoad(char **row)
/* Load a cdsPick from row fetched with select * from cdsPick
* from database. Dispose of this with cdsPickFree(). */
{
struct cdsPick *ret;
AllocVar(ret);
ret->name = cloneString(row[0]);
ret->start = sqlSigned(row[1]);
ret->end = sqlSigned(row[2]);
ret->source = cloneString(row[3]);
ret->score = sqlDouble(row[4]);
ret->startComplete = sqlUnsigned(row[5]);
ret->endComplete = sqlUnsigned(row[6]);
ret->swissProt = cloneString(row[7]);
ret->uniProt = cloneString(row[8]);
ret->refProt = cloneString(row[9]);
ret->refSeq = cloneString(row[10]);
ret->ccds = cloneString(row[11]);
return ret;
}
void bedFileStats(char *bedFile, int colCount, FILE *f)
/* Collect stats on sizes of things in a bed file, and scores too. */
{
struct lineFile *lf = lineFileOpen(bedFile, TRUE);
struct slDouble *sizeList=NULL, *scoreList=NULL, *el;
char *row[colCount];
while (lineFileNextRow(lf, row, colCount))
{
int size = sqlUnsigned(row[endColIx]) - sqlUnsigned(row[startColIx]);
el = slDoubleNew(size);
slAddHead(&sizeList, el);
double score = sqlDouble(row[scoreColIx]);
el = slDoubleNew(score);
slAddHead(&scoreList, el);
}
fprintf(f, "%s\t%d\tsize:", bedFile, slCount(scoreList));
printStats(f, sizeList);
fprintf(f, "\tscore:");
printStats(f, scoreList);
fprintf(f, "\n");
lineFileClose(&lf);
}
struct hash *hashGeneLevels(char *fileName, int cellCount)
/* Get a hash with key of gene name and value an array of expression values. */
{
struct lineFile *lf = lineFileOpen(fileName, TRUE);
struct hash *hash = hashNew(16);
int fieldCount = cellCount+1;
char *words[fieldCount+1];
int wordCount;
while ((wordCount = lineFileChop(lf, words)) != 0)
{
lineFileExpectWords(lf, fieldCount, wordCount);
char *name = words[0];
double *vals;
AllocArray(vals, cellCount);
int i;
for (i=0; i<cellCount; ++i)
vals[i] = sqlDouble(words[i+1]);
hashAdd(hash, name, vals);
}
lineFileClose(&lf);
return hash;
}
