int bigWigOutRegion(char *table, struct sqlConnection *conn,
struct region *region, int maxOut,
enum wigOutputType wigOutType)
/* Write out bigWig for region, doing intersecting and filtering as need be. */
{
boolean isMerged = anySubtrackMerge(table, database);
int resultCount = 0;
char *wigFileName = bigWigFileName(table, conn);
if (wigFileName)
{
struct bbiFile *bwf = bigWigFileOpen(wigFileName);
if (bwf)
{
/* Easy case, just dump out data. */
if (!anyFilter() && !anyIntersection() && !isMerged && wigOutType == wigOutData)
resultCount = bigWigIntervalDump(bwf, region->chrom, region->start, region->end,
maxOut, stdout);
/* Pretty easy case, still do it ourselves. */
else if (!isMerged && wigOutType == wigOutData)
{
double ll, ul;
enum wigCompare cmp;
getWigFilter(database, curTable, &cmp, &ll, &ul);
struct lm *lm = lmInit(0);
struct bbiInterval *ivList, *iv;
ivList = intersectedFilteredBbiIntervalsOnRegion(conn, bwf, region, cmp, ll, ul, lm);
for (iv=ivList; iv != NULL && resultCount < maxOut; iv = iv->next, ++resultCount)
{
fprintf(stdout, "%s\t%d\t%d\t%g\n", region->chrom, iv->start, iv->end, iv->val);
}
lmCleanup(&lm);
}
/* Harder cases - resort to making a data vector and letting that machinery handle it. */
else
{
struct dataVector *dv = bigWigDataVector(table, conn, region);
resultCount = wigPrintDataVectorOut(dv, wigOutType, maxOut, NULL);
dataVectorFree(&dv);
}
}
bbiFileClose(&bwf);
}
freeMem(wigFileName);
return resultCount;
}
boolean doGetBedOrCt(struct sqlConnection *conn, boolean doCt,
boolean doCtFile, boolean redirectToGb)
/* Actually output bed or custom track. Return TRUE unless no results. */
{
char *db = cloneString(database);
char *table = curTable;
struct hTableInfo *hti = getHti(db, table, conn);
struct featureBits *fbList = NULL, *fbPtr;
struct customTrack *ctNew = NULL;
boolean doCtHdr = (cartUsualBoolean(cart, hgtaPrintCustomTrackHeaders, FALSE)
|| doCt || doCtFile);
char *ctWigOutType = cartCgiUsualString(cart, hgtaCtWigOutType, outWigData);
char *fbQual = fbOptionsToQualifier();
char fbTQ[128];
int fields = hTableInfoBedFieldCount(hti);
boolean gotResults = FALSE;
struct region *region, *regionList = getRegions();
boolean isBedGr = isBedGraph(curTable);
boolean isBgWg = isBigWigTable(curTable);
boolean needSubtrackMerge = anySubtrackMerge(database, curTable);
boolean doDataPoints = FALSE;
boolean isWig = isWiggle(database, table);
struct wigAsciiData *wigDataList = NULL;
struct dataVector *dataVectorList = NULL;
boolean doRgb = bedItemRgb(hTrackDbForTrack(db, curTable));
if (!cartUsualBoolean(cart, hgtaDoGreatOutput, FALSE) && !doCt)
{
textOpen();
}
if (cartUsualBoolean(cart, hgtaDoGreatOutput, FALSE))
fputs("#", stdout);
if ((isWig || isBedGr || isBgWg) && sameString(outWigData, ctWigOutType))
doDataPoints = TRUE;
for (region = regionList; region != NULL; region = region->next)
{
struct bed *bedList = NULL, *bed;
struct lm *lm = lmInit(64*1024);
struct dataVector *dv = NULL;
if (isWig && doDataPoints)
{
if (needSubtrackMerge)
{
dv = wiggleDataVector(curTrack, curTable, conn, region);
if (dv != NULL)
slAddHead(&dataVectorList, dv);
}
else
{
int count = 0;
struct wigAsciiData *wigData = NULL;
struct wigAsciiData *asciiData;
struct wigAsciiData *next;
wigData = getWiggleAsData(conn, curTable, region);
for (asciiData = wigData; asciiData; asciiData = next)
{
next = asciiData->next;
if (asciiData->count)
{
slAddHead(&wigDataList, asciiData);
++count;
}
}
slReverse(&wigDataList);
}
}
else if (isBedGr && doDataPoints)
{
dv = bedGraphDataVector(curTable, conn, region);
if (dv != NULL)
slAddHead(&dataVectorList, dv);
}
else if (isBgWg && doDataPoints)
{
dv = bigWigDataVector(curTable, conn, region);
if (dv != NULL)
slAddHead(&dataVectorList, dv);
}
else if (isWig || isBgWg)
{
dv = wiggleDataVector(curTrack, curTable, conn, region);
bedList = dataVectorToBedList(dv);
dataVectorFree(&dv);
}
else if (isBedGr)
{
bedList = getBedGraphAsBed(conn, curTable, region);
}
else
{
bedList = cookedBedList(conn, curTable, region, lm, &fields);
}
/* this is a one-time only initial creation of the custom track
* structure to receive the results. gotResults turns it off after
* the first time.
*/
if (doCtHdr && !gotResults &&
((bedList != NULL) || (wigDataList != NULL) ||
(dataVectorList != NULL)))
{
ctNew = beginCustomTrack(table, fields,
doCt, (isWig || isBedGr || isBgWg), doDataPoints);
}
if (doDataPoints && (wigDataList || dataVectorList))
gotResults = TRUE;
else
{
if ((fbQual == NULL) || (fbQual[0] == 0))
{
for (bed = bedList; bed != NULL; bed = bed->next)
{
if (bed->name != NULL)
{
subChar(bed->name, ' ', '_');
}
if (doCt)
{
struct bed *dupe = cloneBed(bed); /* Out of local memory. */
slAddHead(&ctNew->bedList, dupe);
}
else
{
if (doRgb)
bedTabOutNitemRgb(bed, fields, stdout);
else
bedTabOutN(bed, fields, stdout);
}
gotResults = TRUE;
}
}
else
{
safef(fbTQ, sizeof(fbTQ), "%s:%s", hti->rootName, fbQual);
fbList = fbFromBed(db, fbTQ, hti, bedList, 0, 0, FALSE, FALSE);
if (fields >= 6)
fields = 6;
else if (fields >= 4)
fields = 4;
else
fields = 3;
if (doCt && ctNew)
{
ctNew->fieldCount = fields;
safef(ctNew->tdb->type, strlen(ctNew->tdb->type)+1,
"bed %d", fields);
}
for (fbPtr=fbList; fbPtr != NULL; fbPtr=fbPtr->next)
{
if (fbPtr->name != NULL)
{
char *ptr = strchr(fbPtr->name, ' ');
if (ptr != NULL)
*ptr = 0;
}
if (doCt)
{
struct bed *fbBed = fbToBedOne(fbPtr);
slAddHead(&ctNew->bedList, fbBed );
}
else
{
if (fields >= 6)
hPrintf("%s\t%d\t%d\t%s\t%d\t%c\n",
fbPtr->chrom, fbPtr->start, fbPtr->end, fbPtr->name,
0, fbPtr->strand);
else if (fields >= 4)
hPrintf("%s\t%d\t%d\t%s\n",
fbPtr->chrom, fbPtr->start, fbPtr->end, fbPtr->name);
else
hPrintf("%s\t%d\t%d\n",
fbPtr->chrom, fbPtr->start, fbPtr->end);
}
gotResults = TRUE;
}
featureBitsFreeList(&fbList);
}
}
bedList = NULL;
lmCleanup(&lm);
}
if (!gotResults)
{
hPrintf(NO_RESULTS);
}
else if (doCt)
{
int wigDataSize = 0;
/* Load existing custom tracks and add this new one: */
struct customTrack *ctList = getCustomTracks();
removeNamedCustom(&ctList, ctNew->tdb->table);
if (doDataPoints)
{
if (needSubtrackMerge || isBedGr || isBgWg)
{
slReverse(&dataVectorList);
wigDataSize = dataVectorWriteWigAscii(dataVectorList, ctNew->wigAscii, 0, NULL);
// TODO: see if can make prettier wig output here that
// doesn't necessarily have one value per base
}
else
{
struct wiggleDataStream *wds = NULL;
/* create an otherwise empty wds so we can print out the list */
wds = wiggleDataStreamNew();
wds->ascii = wigDataList;
wigDataSize = wds->asciiOut(wds, db, ctNew->wigAscii, TRUE, FALSE);
#if defined(DEBUG) /* dbg */
/* allow file readability for debug */
chmod(ctNew->wigAscii, 0666);
#endif
wiggleDataStreamFree(&wds);
}
}
else
slReverse(&ctNew->bedList);
slAddHead(&ctList, ctNew);
/* Save the custom tracks out to file (overwrite the old file): */
customTracksSaveCart(db, cart, ctList);
/* Put up redirect-to-browser page. */
if (redirectToGb)
{
char browserUrl[256];
char headerText[512];
int redirDelay = 3;
safef(browserUrl, sizeof(browserUrl),
"%s?%s&db=%s", hgTracksName(), cartSidUrlString(cart), database);
safef(headerText, sizeof(headerText),
"<META HTTP-EQUIV=\"REFRESH\" CONTENT=\"%d;URL=%s\">",
redirDelay, browserUrl);
webStartHeader(cart, database, headerText,
"Table Browser: %s %s: %s", hOrganism(database),
freezeName, "get custom track");
if (doDataPoints)
{
hPrintf("There are %d data points in custom track. ", wigDataSize);
}
else
{
hPrintf("There are %d items in custom track. ",
slCount(ctNew->bedList));
}
hPrintf("You will be automatically redirected to the genome browser in\n"
"%d seconds, or you can \n"
"<A HREF=\"%s\">click here to continue</A>.\n",
redirDelay, browserUrl);
}
}
else if (doDataPoints)
{
if (needSubtrackMerge || isBedGr || isBgWg)
{
slReverse(&dataVectorList);
dataVectorWriteWigAscii(dataVectorList, "stdout", 0, NULL);
}
else
{
/* create an otherwise empty wds so we can print out the list */
struct wiggleDataStream *wds = NULL;
wds = wiggleDataStreamNew();
wds->ascii = wigDataList;
wds->asciiOut(wds, db, "stdout", TRUE, FALSE);
wiggleDataStreamFree(&wds);
}
}
return gotResults;
}
