static void bigWigLoadItems(struct track *tg)
/* Fill up tg->items with bedGraphItems derived from a bigWig file */
{
char *extTableString = trackDbSetting(tg->tdb, "extTable");
if (extTableString != NULL)
{
// if there's an extra table, read this one in too
struct sqlConnection *conn = hAllocConnTrack(database, tg->tdb);
char *fileName = bbiNameFromTable(conn, tg->table);
struct bbiFile *bbiFile = bigWigFileOpen(fileName);
slAddHead(&tg->bbiFile, bbiFile);
fileName = bbiNameFromTable(conn, extTableString);
bbiFile = bigWigFileOpen(fileName);
slAddHead(&tg->bbiFile, bbiFile);
hFreeConn(&conn);
}
else
{
if (tg->bbiFile == NULL)
{
/* Figure out bigWig file name. */
struct sqlConnection *conn = hAllocConnTrack(database, tg->tdb);
char *fileName = bbiNameFromTable(conn, tg->table);
tg->bbiFile = bigWigFileOpen(fileName);
hFreeConn(&conn);
}
}
}
struct bbiFile *fetchBbiForTrack(struct track *track)
/* Fetch bbiFile from track, opening it if it is not already open. */
{
struct bbiFile *bbi = track->bbiFile;
if (bbi == NULL)
{
char *fileName = NULL;
if (track->parallelLoading) // do not use mysql during parallel fetch
{
fileName = cloneString(trackDbSetting(track->tdb, "bigDataUrl"));
}
else
{
struct sqlConnection *conn = NULL;
if (!trackHubDatabase(database))
conn = hAllocConnTrack(database, track->tdb);
fileName = bbiNameFromSettingOrTable(track->tdb, conn, track->table);
hFreeConn(&conn);
}
#ifdef USE_GBIB_PWD
#include "gbib.c"
#endif
bbi = track->bbiFile = bigBedFileOpen(fileName);
}
return bbi;
}
int bbExtraFieldIndex(struct trackDb *tdb, char* fieldName)
/* return the index of a given extra field from the bbInterval
* 0 is the name-field of bigBed and is used as an error code
* as this is the default anyways */
{
if (fieldName==NULL)
return 0;
// copied from hgc.c
// get .as file for track
struct sqlConnection *conn = NULL ;
if (!trackHubDatabase(database))
conn = hAllocConnTrack(database, tdb);
struct asObject *as = asForTdb(conn, tdb);
hFreeConn(&conn);
if (as == NULL)
return 0;
// search for field name, return index if found
struct asColumn *col = as->columnList;
int ix = 0;
for (;col != NULL;col=col->next, ix+=1)
if (sameString(col->name, fieldName))
return max(ix-3, 0); // never return a negative value
return 0;
}
void doVcfTabixDetails(struct trackDb *tdb, char *item)
/* Show details of an alignment from a VCF file compressed and indexed by tabix. */
{
knetUdcInstall();
if (udcCacheTimeout() < 300)
udcSetCacheTimeout(300);
struct sqlConnection *conn = hAllocConnTrack(database, tdb);
char *fileOrUrl = bbiNameFromSettingOrTableChrom(tdb, conn, tdb->table, seqName);
hFreeConn(&conn);
doVcfDetailsCore(tdb, fileOrUrl, TRUE);
}
static void vcfTabixLoadItems(struct track *tg)
/* Load items in window from VCF file using its tabix index file. */
{
char *fileOrUrl = NULL;
/* Figure out url or file name. */
if (tg->parallelLoading)
{
/* do not use mysql during parallel-fetch load */
fileOrUrl = trackDbSetting(tg->tdb, "bigDataUrl");
}
else
{
struct sqlConnection *conn = hAllocConnTrack(database, tg->tdb);
fileOrUrl = bbiNameFromSettingOrTableChrom(tg->tdb, conn, tg->table, chromName);
hFreeConn(&conn);
}
if (isEmpty(fileOrUrl))
return;
int vcfMaxErr = -1;
struct vcfFile *vcff = NULL;
boolean hapClustEnabled = cartOrTdbBoolean(cart, tg->tdb, VCF_HAP_ENABLED_VAR, TRUE);
/* protect against temporary network error */
struct errCatch *errCatch = errCatchNew();
if (errCatchStart(errCatch))
{
vcff = vcfTabixFileMayOpen(fileOrUrl, chromName, winStart, winEnd, vcfMaxErr, -1);
if (vcff != NULL)
{
filterRecords(vcff, tg->tdb);
if (hapClustEnabled && vcff->genotypeCount > 1 && vcff->genotypeCount < 3000 &&
(tg->visibility == tvPack || tg->visibility == tvSquish))
vcfHapClusterOverloadMethods(tg, vcff);
else
{
tg->items = vcfFileToPgSnp(vcff, tg->tdb);
// pgSnp bases coloring/display decision on count of items:
tg->customInt = slCount(tg->items);
}
// Don't vcfFileFree here -- we are using its string pointers!
}
}
errCatchEnd(errCatch);
if (errCatch->gotError || vcff == NULL)
{
if (isNotEmpty(errCatch->message->string))
tg->networkErrMsg = cloneString(errCatch->message->string);
tg->drawItems = bigDrawWarning;
tg->totalHeight = bigWarnTotalHeight;
}
errCatchFree(&errCatch);
}
static void bamWigLoadItems(struct track *tg)
{
char *fileName = NULL;
/* Figure out bigWig file name. */
if (tg->parallelLoading)
{
/* do not use mysql during parallel-fetch load */
fileName = trackDbSetting(tg->tdb, "bigDataUrl");
}
else
{
struct sqlConnection *conn = hAllocConnTrack(database, tg->tdb);
/* this should call bamFileNameFromTable with logic from bamLoadItemsCore to
* check the bigDataUrl setting. Fix this if bamWigs end up being
* a supported type. It may be that this code gets rolled into
* normal BAM display... since that's the plan ;-).
*/
fileName = bbiNameFromSettingOrTable(tg->tdb, conn, tg->table);
hFreeConn(&conn);
}
/* Allocate predraw area. */
struct bamWigTrackData *bwData;
double scale = (double)insideWidth/(winEnd - winStart);
struct preDrawContainer *pre = tg->preDrawContainer = initPreDrawContainer(insideWidth);
AllocVar(bwData);
bwData->preDraw = pre->preDraw;
bwData->scale = scale;
bwData->width = insideWidth;
bwData->preDrawZero = pre->preDrawZero;
char posForBam[512];
safef(posForBam, sizeof(posForBam), "%s:%d-%d", chromName, winStart, winEnd);
bamFetch(fileName, posForBam, countBam, bwData, NULL);
/* fill in rest of predraw */
int preDrawZero = pre->preDrawZero;
int i;
for (i=0; i<insideWidth; ++i)
{
struct preDrawElement *pe = &bwData->preDraw[i + preDrawZero];
pe->min = pe->count;
pe->max = pe->count;
pe->sumData = pe->count / scale;
pe->sumSquares = (pe->count * pe->count)/scale;
}
}
void loadBed9(struct track *tg)
/* Convert bed 9 info in window to linked feature. (to handle itemRgb)*/
{
struct trackDb *tdb = tg->tdb;
struct bed *bed;
struct linkedFeatures *lfList = NULL, *lf;
int scoreMin = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMin", "0"));
int scoreMax = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMax", "1000"));
boolean useItemRgb = FALSE;
useItemRgb = bedItemRgb(tdb);
if (tg->isBigBed)
{ // avoid opening an unneeded db connection for bigBed; required not to use mysql for parallel fetch tracks
bigBedAddLinkedFeaturesFrom(tg, chromName, winStart, winEnd,
scoreMin, scoreMax, useItemRgb, 9, &lfList);
}
else
{
struct sqlConnection *conn = hAllocConnTrack(database, tdb);
struct sqlResult *sr;
char **row;
int rowOffset;
char *scoreFilterClause = getScoreFilterClause(cart, tg->tdb,NULL);
if (scoreFilterClause != NULL)
{
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd,scoreFilterClause, &rowOffset);
freeMem(scoreFilterClause);
}
else
{
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd,
NULL, &rowOffset);
}
while ((row = sqlNextRow(sr)) != NULL)
{
bed = bedLoadN(row+rowOffset, 9);
lf = bedMungToLinkedFeatures(&bed, tdb, 9, scoreMin, scoreMax, useItemRgb);
slAddHead(&lfList, lf);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
}
slReverse(&lfList);
slSort(&lfList, linkedFeaturesCmp);
tg->items = lfList;
}
static void vcfLoadItems(struct track *tg)
/* Load items in window from VCF file. */
{
int vcfMaxErr = -1;
struct vcfFile *vcff = NULL;
boolean hapClustEnabled = cartOrTdbBoolean(cart, tg->tdb, VCF_HAP_ENABLED_VAR, TRUE);
char *table = tg->table;
struct customTrack *ct = tg->customPt;
struct sqlConnection *conn;
if (ct == NULL)
conn = hAllocConnTrack(database, tg->tdb);
else
{
conn = hAllocConn(CUSTOM_TRASH);
table = ct->dbTableName;
}
char *vcfFile = bbiNameFromSettingOrTable(tg->tdb, conn, table);
hFreeConn(&conn);
/* protect against parse error */
struct errCatch *errCatch = errCatchNew();
if (errCatchStart(errCatch))
{
vcff = vcfFileMayOpen(vcfFile, chromName, winStart, winEnd, vcfMaxErr, -1, TRUE);
if (vcff != NULL)
{
filterRecords(vcff, tg->tdb);
if (hapClustEnabled && vcff->genotypeCount > 1 && vcff->genotypeCount < 3000 &&
(tg->visibility == tvPack || tg->visibility == tvSquish))
vcfHapClusterOverloadMethods(tg, vcff);
else
{
tg->items = vcfFileToPgSnp(vcff, tg->tdb);
// pgSnp bases coloring/display decision on count of items:
tg->customInt = slCount(tg->items);
}
// Don't vcfFileFree here -- we are using its string pointers!
}
}
errCatchEnd(errCatch);
if (errCatch->gotError || vcff == NULL)
{
if (isNotEmpty(errCatch->message->string))
tg->networkErrMsg = cloneString(errCatch->message->string);
tg->drawItems = bigDrawWarning;
tg->totalHeight = bigWarnTotalHeight;
}
errCatchFree(&errCatch);
}
void doVcfDetails(struct trackDb *tdb, char *item)
/* Show details of an alignment from an uncompressed VCF file. */
{
struct customTrack *ct = lookupCt(tdb->track);
struct sqlConnection *conn = NULL;
char *table = tdb->table;
if (ct)
{
conn = hAllocConn(CUSTOM_TRASH);
table = ct->dbTableName;
}
else
conn = hAllocConnTrack(database, tdb);
char *fileOrUrl = bbiNameFromSettingOrTableChrom(tdb, conn, table, seqName);
hFreeConn(&conn);
doVcfDetailsCore(tdb, fileOrUrl, FALSE);
}
static struct bed *loadMsBed(struct trackDb *tdb, char *table, char *chrom, uint start, uint end)
/* load every thing from a bed 15 table in the given range */
{
struct sqlConnection *conn = hAllocConnTrack(database, tdb);
struct sqlResult *sr;
char **row;
int rowOffset;
struct bed *bedList = NULL, *bed;
sr = hRangeQuery(conn, table, chrom, start, end, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
bed = bedLoadN(row+rowOffset, 15);
slAddHead(&bedList, bed);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
slReverse(&bedList);
return bedList;
}
struct bed *getRegionAsBed(
char *db, char *table, /* Database and table. */
struct region *region, /* Region to get data for. */
char *filter, /* Filter to add to SQL where clause if any. */
struct hash *idHash, /* Restrict to id's in this hash if non-NULL. */
struct lm *lm, /* Where to allocate memory. */
int *retFieldCount) /* Number of fields. */
/* Return a bed list of all items in the given range in table.
* Cleanup result via lmCleanup(&lm) rather than bedFreeList. */
{
char *fields = NULL;
struct sqlResult *sr;
struct hTableInfo *hti;
struct bed *bedList=NULL, *bed;
char **row;
int fieldCount;
boolean isPsl, isGenePred, isBedWithBlocks;
boolean pslKnowIfProtein = FALSE, pslIsProtein = FALSE;
struct sqlConnection *conn = NULL;
char *dbTable = NULL;
if (isCustomTrack(table))
{
struct customTrack *ct = ctLookupName(table);
dbTable = ct->dbTableName;
conn = hAllocConn(CUSTOM_TRASH);
hti = hFindTableInfo(CUSTOM_TRASH, region->chrom, dbTable);
}
else
{
dbTable = table;
struct trackDb *tdb;
if(sameWord(db, database))
tdb = tdbForTrack(db, table, &fullTrackList);
else
tdb = hTrackDbForTrack(db, table);
conn = (tdb ? hAllocConnTrack(db, tdb) : hAllocConn(db));
hti = hFindTableInfo(db, region->chrom, table);
}
if (hti == NULL)
errAbort("Could not find table info for table %s.%s", db,table);
if (isWiggle(db, table))
{
bedList = getWiggleAsBed(db, table, region, filter, idHash, lm, conn);
fieldCount = 4;
}
else
{
bedSqlFieldsExceptForChrom(hti, &fieldCount, &fields);
isPsl = htiIsPsl(hti);
isGenePred = sameString("exonEnds", hti->endsSizesField);
isBedWithBlocks = (
(sameString("chromStarts", hti->startsField) ||
sameString("blockStarts", hti->startsField))
&& sameString("blockSizes", hti->endsSizesField));
/* All beds have at least chrom,start,end. We omit the chrom
* from the query since we already know it. */
sr = regionQuery(conn, dbTable, fields, region, TRUE, filter);
while (sr != NULL && (row = sqlNextRow(sr)) != NULL)
{
/* If have a name field apply hash filter. */
if (fieldCount >= 4 && idHash != NULL)
if (!hashLookup(idHash, row[2]))
continue;
bed = bedFromRow(region->chrom, row, fieldCount, isPsl, isGenePred,
isBedWithBlocks, &pslKnowIfProtein, &pslIsProtein, lm);
slAddHead(&bedList, bed);
}
freez(&fields);
sqlFreeResult(&sr);
slReverse(&bedList);
}
hFreeConn(&conn);
if (retFieldCount)
*retFieldCount = fieldCount;
return(bedList);
}
/* bedGraphLoadItems - an ordinary bed load, but we are interested
* in only the chrom, start, end, and the graphColumn
*/
static void bedGraphLoadItems(struct track *tg)
{
struct sqlConnection *conn;
struct sqlResult *sr = (struct sqlResult *) NULL;
char **row = (char **)NULL;
int rowOffset = 0;
struct bedGraphItem *bgList = NULL;
int itemsLoaded = 0;
int colCount = 0;
struct wigCartOptions *wigCart = (struct wigCartOptions *) tg->wigCartData;
int graphColumn = 5;
char *tableName;
if(sameString(tg->table, "affyTranscription"))
wigCart->colorTrack = "affyTransfrags";
graphColumn = wigCart->graphColumn;
#ifndef GBROWSE
if (isCustomTrack(tg->table) && tg->customPt)
{
struct customTrack *ct = (struct customTrack *) tg->customPt;
tableName = ct->dbTableName;
conn = hAllocConn(CUSTOM_TRASH);
}
else
#endif /* GBROWSE */
{
tableName = tg->table;
conn = hAllocConnTrack(database, tg->tdb);
}
sr = hRangeQuery(conn, tableName, chromName, winStart, winEnd, NULL,
&rowOffset);
colCount = sqlCountColumns(sr) - rowOffset;
/* Must have at least four good columns */
if (colCount < 4)
errAbort("bedGraphLoadItems: table %s only has %d data columns, must be at least 4", tableName, colCount);
if (colCount < graphColumn)
errAbort("bedGraphLoadItems: table %s only has %d data columns, specified graph column %d does not exist",
tableName, colCount, graphColumn);
/* before loop, determine actual row[graphColumn] index */
graphColumn += (rowOffset - 1);
while ((row = sqlNextRow(sr)) != NULL)
{
struct bedGraphItem *bg;
struct bed *bed;
++itemsLoaded;
/* load chrom, start, end */
bed = bedLoadN(row+rowOffset, 3);
AllocVar(bg);
bg->start = bed->chromStart;
bg->end = bed->chromEnd;
if ((colCount > 4) && ((graphColumn + rowOffset) != 4))
bg->name = cloneString(row[3+rowOffset]);
else
{
char name[128];
safef(name,ArraySize(name),"%s.%d", bed->chrom, itemsLoaded);
bg->name = cloneString(name);
}
bg->dataValue = sqlFloat(row[graphColumn]);
/* filled in by DrawItems */
bg->graphUpperLimit = wigEncodeStartingUpperLimit;
bg->graphLowerLimit = wigEncodeStartingLowerLimit;
slAddHead(&bgList, bg);
bedFree(&bed);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
slReverse(&bgList);
tg->items = bgList;
} /* bedGraphLoadItems() */
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 doBamDetails(struct trackDb *tdb, char *item)
/* Show details of an alignment from a BAM file. */
{
if (item == NULL)
errAbort("doBamDetails: NULL item name");
int start = cartInt(cart, "o");
if (!tdb || !trackDbSetting(tdb, "bamSkipPrintQualScore"))
skipQualityScore = FALSE;
else
skipQualityScore = TRUE;
// TODO: libify tdb settings table_pairEndsByName, stripPrefix and pairSearchRange
knetUdcInstall();
if (udcCacheTimeout() < 300)
udcSetCacheTimeout(300);
if (sameString(item, "zoom in"))
printf("Zoom in to a region with fewer items to enable 'detail page' links for individual items.<BR>");
char varName[1024];
safef(varName, sizeof(varName), "%s_pairEndsByName", tdb->track);
boolean isPaired = cartUsualBoolean(cart, varName,
(trackDbSetting(tdb, "pairEndsByName") != NULL));
char position[512];
safef(position, sizeof(position), "%s:%d-%d", seqName, winStart, winEnd);
struct hash *pairHash = isPaired ? hashNew(0) : NULL;
struct bamTrackData btd = {start, item, pairHash};
char *fileName = hReplaceGbdb(trackDbSetting(tdb, "bigDataUrl"));
if (fileName == NULL)
{
if (isCustomTrack(tdb->table))
{
errAbort("bamLoadItemsCore: can't find bigDataUrl for custom track %s", tdb->track);
}
else
{
struct sqlConnection *conn = hAllocConnTrack(database, tdb);
fileName = hReplaceGbdb(bamFileNameFromTable(conn, tdb->table, seqName));
hFreeConn(&conn);
}
}
char *indexName = hReplaceGbdb(trackDbSetting(tdb, "bigDataIndex"));
char *cacheDir = cfgOption("cramRef");
char *refUrl = trackDbSetting(tdb, "refUrl");
bamAndIndexFetchPlus(fileName, indexName, position, oneBam, &btd, NULL, refUrl, cacheDir);
if (isPaired)
{
char *setting = trackDbSettingOrDefault(tdb, "pairSearchRange", "20000");
int pairSearchRange = atoi(setting);
if (pairSearchRange > 0 && hashNumEntries(pairHash) > 0)
{
// Repeat the search for item in a larger window:
struct hash *newPairHash = hashNew(0);
btd.pairHash = newPairHash;
safef(position, sizeof(position), "%s:%d-%d", seqName,
max(0, winStart-pairSearchRange), winEnd+pairSearchRange);
bamFetch(fileName, position, oneBam, &btd, NULL);
}
struct hashEl *hel;
struct hashCookie cookie = hashFirst(btd.pairHash);
while ((hel = hashNext(&cookie)) != NULL)
{
bam1_t *bam = hel->val;
const bam1_core_t *core = &bam->core;
if (! (core->flag & BAM_FMUNMAP))
printf("<B>Note: </B>unable to find paired end for %s "
"within +-%d bases of viewing window %s<BR>\n",
item, pairSearchRange, addCommasToPos(database, cartString(cart, "position")));
else
printf("<B>Paired read name:</B> %s<BR>\n", item);
singleBamDetails(bam);
}
}
}
void bamLoadItemsCore(struct track *tg, boolean isPaired)
/* Load BAM data into tg->items item list, unless zoomed out so far
* that the data would just end up in dense mode and be super-slow. */
{
/* protect against temporary network error */
struct errCatch *errCatch = errCatchNew();
if (errCatchStart(errCatch))
{
struct hash *pairHash = isPaired ? hashNew(18) : NULL;
int minAliQual = atoi(cartOrTdbString(cart, tg->tdb, BAM_MIN_ALI_QUAL, BAM_MIN_ALI_QUAL_DEFAULT));
char *colorMode = cartOrTdbString(cart, tg->tdb, BAM_COLOR_MODE, BAM_COLOR_MODE_DEFAULT);
char *grayMode = cartOrTdbString(cart, tg->tdb, BAM_GRAY_MODE, BAM_GRAY_MODE_DEFAULT);
char *userTag = cartOrTdbString(cart, tg->tdb, BAM_COLOR_TAG, BAM_COLOR_TAG_DEFAULT);
int aliQualShadeMin = 0, aliQualShadeMax = 99, baseQualShadeMin = 0, baseQualShadeMax = 40;
parseIntRangeSetting(tg->tdb, "aliQualRange", &aliQualShadeMin, &aliQualShadeMax);
parseIntRangeSetting(tg->tdb, "baseQualRange", &baseQualShadeMin, &baseQualShadeMax);
struct bamTrackData btd = {tg, pairHash, minAliQual, colorMode, grayMode, userTag,
aliQualShadeMin, aliQualShadeMax, baseQualShadeMin, baseQualShadeMax};
char *fileName = trackDbSetting(tg->tdb, "bigDataUrl");
if (fileName == NULL)
{
if (tg->customPt)
{
errAbort("bamLoadItemsCore: can't find bigDataUrl for custom track %s", tg->track);
}
else
{
struct sqlConnection *conn = hAllocConnTrack(database, tg->tdb);
fileName = bamFileNameFromTable(conn, tg->table, chromName);
hFreeConn(&conn);
}
}
char *fileName2 = hReplaceGbdb(fileName);
char posForBam[512];
safef(posForBam, sizeof(posForBam), "%s:%d-%d", chromName, winStart, winEnd);
char *cacheDir = cfgOption("cramRef");
char *refUrl = trackDbSetting(tg->tdb, "refUrl");
if (!isPaired)
bamFetchPlus(fileName2, posForBam, addBam, &btd, NULL, refUrl, cacheDir);
else
{
char *setting = trackDbSettingClosestToHomeOrDefault(tg->tdb, "pairSearchRange", "20000");
int pairSearchRange = atoi(setting);
if (pairSearchRange > 0)
safef(posForBam, sizeof(posForBam), "%s:%d-%d", chromName,
max(0, winStart-pairSearchRange), winEnd+pairSearchRange);
bamFetchPlus(fileName2, posForBam, addBamPaired, &btd, NULL, refUrl, cacheDir);
struct hashEl *hel;
struct hashCookie cookie = hashFirst(btd.pairHash);
while ((hel = hashNext(&cookie)) != NULL)
{
struct linkedFeatures *lf = hel->val;
if (lf->start < winEnd && lf->end > winStart)
slAddHead(&(tg->items), lfsFromLf(lf));
}
}
freez(&fileName2);
if (tg->visibility != tvDense)
{
slReverse(&(tg->items));
if (isPaired)
slSort(&(tg->items), linkedFeaturesSeriesCmp);
else if (sameString(colorMode, BAM_COLOR_MODE_STRAND))
slSort(&(tg->items), linkedFeaturesCmpOri);
else if (sameString(colorMode, BAM_COLOR_MODE_GRAY) &&
sameString(grayMode, BAM_GRAY_MODE_ALI_QUAL))
slSort(&(tg->items), linkedFeaturesCmpScore);
else
slSort(&(tg->items), linkedFeaturesCmpStart);
if (slCount(tg->items) > MAX_ITEMS_FOR_MAPBOX)
{
// flag drawItems to make a mapBox for the whole track
tg->customInt = 1;
tg->mapItem = dontMapItem;
}
}
}
errCatchEnd(errCatch);
if (errCatch->gotError)
{
tg->networkErrMsg = cloneString(errCatch->message->string);
tg->drawItems = bigDrawWarning;
tg->totalHeight = bigWarnTotalHeight;
}
errCatchFree(&errCatch);
}
