struct bed *bedFilterList(struct bed *bedListIn, struct bedFilter *bf)
/* Given a bed list and a bedFilter which specifies constraints on bed
* fields, return the list of bed items that meet the constraints. */
{
return bedFilterListInRange(bedListIn, bf, NULL, 0, 0);
}
void loadSimpleBed(struct track *tg)
/* Load the items in one track - just move beds in
* window... */
{
struct bed *(*loader)(char **row);
struct bed *bed, *list = NULL;
char **row;
int rowOffset;
char *words[3];
int wordCt;
char query[128];
char *setting = NULL;
bool doScoreCtFilter = FALSE;
int scoreFilterCt = 0;
char *topTable = NULL;
if (tg->bedSize <= 3)
loader = bedLoad3;
else if (tg->bedSize == 4)
loader = bedLoad;
else if (tg->bedSize == 5)
loader = bedLoad5;
else
loader = bedLoad6;
// pairedTagAlign loader is required for base coloring using sequence from seq1 & seq2
// after removing optional bin column, this loader assumes seq1 and seq2 are in
// row[6] and row[7] respectively of the sql result.
if ((setting = trackDbSetting(tg->tdb, BASE_COLOR_USE_SEQUENCE))
&& sameString(setting, "seq1Seq2"))
loader = bedLoadPairedTagAlign;
/* limit to a specified count of top scoring items.
* If this is selected, it overrides selecting item by specified score */
if ((setting = trackDbSettingClosestToHome(tg->tdb, "filterTopScorers")) != NULL)
{
wordCt = chopLine(cloneString(setting), words);
if (wordCt >= 3)
{
doScoreCtFilter = cartUsualBooleanClosestToHome(cart, tg->tdb, FALSE,
"filterTopScorersOn",sameString(words[0], "on"));
scoreFilterCt = cartUsualIntClosestToHome(cart, tg->tdb, FALSE,
"filterTopScorersCt", atoi(words[1]));
topTable = words[2];
/* if there are not too many rows in the table then can define */
/* top table as the track or subtrack table */
if (sameWord(topTable, "self"))
topTable = cloneString(tg->table);
}
}
/* Get list of items */
if (tg->isBigBed)
{ // avoid opening an unneeded db connection for bigBed; required not to use mysql for parallel fetch tracks
char *scoreFilter = cartOrTdbString(cart, tg->tdb, "scoreFilter", NULL);
struct lm *lm = lmInit(0);
struct bigBedInterval *bb, *bbList = bigBedSelectRange(tg, chromName, winStart, winEnd, lm);
char *bedRow[32];
char startBuf[16], endBuf[16];
int minScore = 0;
if (scoreFilter)
minScore = atoi(scoreFilter);
for (bb = bbList; bb != NULL; bb = bb->next)
{
bigBedIntervalToRow(bb, chromName, startBuf, endBuf, bedRow, ArraySize(bedRow));
bed = loader(bedRow);
if (scoreFilter == NULL || bed->score >= minScore)
slAddHead(&list, bed);
}
lmCleanup(&lm);
}
else
{
struct sqlConnection *conn = hAllocConnTrack(database, tg->tdb);
struct sqlResult *sr = NULL;
/* limit to items above a specified score */
char *scoreFilterClause = getScoreFilterClause(cart, tg->tdb,NULL);
if (doScoreCtFilter && (topTable != NULL) && hTableExists(database, topTable))
{
sqlSafef(query, sizeof(query),"select * from %s order by score desc limit %d",
topTable, scoreFilterCt);
sr = sqlGetResult(conn, query);
rowOffset = hOffsetPastBin(database, hDefaultChrom(database), topTable);
}
else if(scoreFilterClause != NULL && tg->bedSize >= 5)
{
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd, scoreFilterClause, &rowOffset);
}
else
{
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd, NULL, &rowOffset);
}
freeMem(scoreFilterClause);
while ((row = sqlNextRow(sr)) != NULL)
{
bed = loader(row+rowOffset);
slAddHead(&list, bed);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
}
if (doScoreCtFilter)
{
/* filter out items not in this window */
struct bed *newList = bedFilterListInRange(list, NULL, chromName, winStart, winEnd);
list = newList;
}
slReverse(&list);
tg->items = list;
}
void doExpRatio(struct trackDb *tdb, char *item, struct customTrack *ct)
/* Generic expression ratio deatils using microarrayGroups.ra file */
/* and not the expRecord tables. */
{
char *expScale = trackDbRequiredSetting(tdb, "expScale");
char *expStep = trackDbRequiredSetting(tdb, "expStep");
double maxScore = atof(expScale);
double stepSize = atof(expStep);
struct bed *bedList;
char *itemName = cgiUsualString("i2","none");
char *expName = (item == NULL) ? itemName : item;
char *tdbSetting = trackDbSettingOrDefault(tdb, "expColor", "redGreen");
char *colorVal = NULL;
enum expColorType colorScheme;
char colorVarName[256];
safef(colorVarName, sizeof(colorVarName), "%s.color", tdb->track);
colorVal = cartUsualString(cart, colorVarName, tdbSetting);
colorScheme = getExpColorType(colorVal);
if (sameWord(tdb->grp, "cancerGenomics"))
{
/* set global flag */
isCancerGenomicsTrack = TRUE;
}
if (!ct)
{
genericHeader(tdb, itemName);
bedList = loadMsBed(tdb, tdb->table, seqName, winStart, winEnd);
}
else if (ct->dbTrack)
{
genericHeader(tdb, itemName);
printCustomUrl(tdb, itemName, TRUE);
bedList = ctLoadMultScoresBedDb(ct, seqName, winStart, winEnd);
}
else
bedList = bedFilterListInRange(ct->bedList, NULL, seqName, winStart, winEnd);
if (bedList == NULL)
printf("<b>No Expression Data in this Range.</b>\n");
else if (expName && sameString(expName, "zoomInMore"))
printf("<b>Too much data to display in detail in this range.</b>\n");
else
{
struct microarrayGroups *groupings = NULL;
struct maGrouping *combineGroup;
struct hash *erHash = newHash(6);
int i;
if (!ct)
{
groupings = maGetTrackGroupings(database, tdb);
combineGroup = maCombineGroupingFromCart(groupings, cart, tdb->track);
}
else
combineGroup = maGetGroupingFromCt(ct);
maBedClumpGivenGrouping(bedList, combineGroup);
for (i = 0; i < combineGroup->numGroups; i++)
{
/* make stupid exprecord hash.perhaps eventually this won't be needed */
char id[16];
struct expRecord *er = basicExpRecord(combineGroup->names[i], i, 2);
safef(id, sizeof(id), "%d", i);
hashAdd(erHash, id, er);
}
puts("<h2></h2><p>\n");
msBedPrintTable(bedList, erHash, itemName, expName, -1*maxScore, maxScore,
stepSize, 2, msBedDefaultPrintHeader, msBedExpressionPrintRow,
printExprssnColorKey, getColorForExprBed, colorScheme);
hashTraverseEls(erHash, erHashElFree);
hashFree(&erHash);
microarrayGroupsFree(&groupings);
}
puts("<h2></h2><p>\n");
bedFreeList(&bedList);
}
