Bits *bitsForIntersectingTable(struct sqlConnection *conn, struct region *region, int chromSize,
boolean isBpWise)
/* Get a bitmap that corresponds to the table we are intersecting with.
* Consult CGI vars to figure out what table it is. */
{
boolean invTable2 = cartCgiUsualBoolean(cart, hgtaInvertTable2, FALSE);
char *table2 = cartString(cart, hgtaIntersectTable);
struct hTableInfo *hti2 = getHti(database, table2, conn);
struct lm *lm2 = lmInit(64*1024);
Bits *bits2 = bitAlloc(chromSize+8);
struct bed *bedList2;
if (isBigWigTable(table2))
bedList2 = bigWigIntervalsToBed(conn, table2, region, lm2);
else
// We should go straight to raw beds here, not through the routines that
// do filter & intersections, because the secondary table has no filter
// and sure shouldn't be intersected. :)
bedList2 = getFilteredBeds(conn, table2, region, lm2, NULL);
if (!isBpWise)
expandZeroSize(bedList2, hti2->hasBlocks, chromSize);
bedOrBits(bits2, chromSize, bedList2, hti2->hasBlocks, 0);
if (invTable2)
bitNot(bits2, chromSize);
lmCleanup(&lm2);
return bits2;
}
Bits *bitsForIntersectingTable(struct sqlConnection *conn, struct region *region, int chromSize,
boolean isBpWise)
/* Get a bitmap that corresponds to the table we are intersecting with.
* Consult CGI vars to figure out what table it is. */
{
boolean invTable2 = cartCgiUsualBoolean(cart, hgtaInvertTable2, FALSE);
char *table2 = cartString(cart, hgtaIntersectTable);
struct hTableInfo *hti2 = getHti(database, table2, conn);
struct lm *lm2 = lmInit(64*1024);
Bits *bits2 = bitAlloc(chromSize+8);
struct bed *bedList2 = getFilteredBeds(conn, table2, region, lm2, NULL);
if (!isBpWise)
expandZeroSize(bedList2, hti2->hasBlocks, chromSize);
bedOrBits(bits2, chromSize, bedList2, hti2->hasBlocks, 0);
if (invTable2)
bitNot(bits2, chromSize);
lmCleanup(&lm2);
return bits2;
}
struct bed *getRegionAsMergedBed(
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 subtrack-merged table.
* Cleanup result via lmCleanup(&lm) rather than bedFreeList. */
{
if (! anySubtrackMerge(db, table))
return getRegionAsBed(db, table, region, filter, idHash, lm, retFieldCount);
else
{
struct hTableInfo *hti = getHtiOnDb(database, table);
int chromSize = hChromSize(database, region->chrom);
Bits *bits1 = NULL;
Bits *bits2 = NULL;
struct bed *bedMerged = NULL;
struct trackDb *subtrack = NULL;
char *primaryType = findTypeForTable(database,curTrack,table, ctLookupName);
char *op = cartString(cart, hgtaSubtrackMergeOp);
boolean isBpWise = (sameString(op, "and") || sameString(op, "or"));
double moreThresh = cartDouble(cart, hgtaSubtrackMergeMoreThreshold);
double lessThresh = cartDouble(cart, hgtaSubtrackMergeLessThreshold);
boolean firstTime = TRUE;
if (sameString(op, "cat"))
{
struct bed *bedList = getRegionAsBed(db, table, region, filter,
idHash, lm, retFieldCount);
struct slRef *tdbRefList = trackDbListGetRefsToDescendantLeaves(curTrack->subtracks);
struct slRef *tdbRef;
for (tdbRef = tdbRefList; tdbRef != NULL; tdbRef = tdbRef->next)
{
subtrack = tdbRef->val;
if (! sameString(curTable, subtrack->table) &&
isSubtrackMerged(subtrack->table) &&
sameString(subtrack->type, primaryType))
{
struct bed *bedList2 =
getRegionAsBed(db, subtrack->table, region, NULL,
idHash, lm, retFieldCount);
bedList = slCat(bedList, bedList2);
}
}
slFreeList(&tdbRefList);
return bedList;
}
bits1 = bitAlloc(chromSize+8);
bits2 = bitAlloc(chromSize+8);
/* If doing a base-pair-wise operation, then start with the primary
* subtrack's ranges in bits1, and AND/OR all the selected subtracks'
* ranges into bits1. If doing a non-bp-wise intersection, then
* start with all bits clear in bits1, and then OR selected subtracks'
* ranges into bits1. */
if (isBpWise)
{
struct lm *lm2 = lmInit(64*1024);
struct bed *bedList1 = getRegionAsBed(db, table, region, filter,
idHash, lm2, retFieldCount);
bedOrBits(bits1, chromSize, bedList1, hti->hasBlocks, 0);
lmCleanup(&lm2);
}
struct slRef *tdbRefList = trackDbListGetRefsToDescendantLeaves(curTrack->subtracks);
struct slRef *tdbRef;
for (tdbRef = tdbRefList; tdbRef != NULL; tdbRef = tdbRef->next)
{
subtrack = tdbRef->val;
if (! sameString(curTable, subtrack->table) &&
isSubtrackMerged(subtrack->table) &&
sameString(subtrack->type, primaryType))
{
struct hTableInfo *hti2 = getHtiOnDb(database, subtrack->table);
struct lm *lm2 = lmInit(64*1024);
struct bed *bedList2 =
getRegionAsBed(db, subtrack->table, region, NULL, idHash,
lm2, NULL);
if (firstTime)
firstTime = FALSE;
else
bitClear(bits2, chromSize);
bedOrBits(bits2, chromSize, bedList2, hti2->hasBlocks, 0);
if (sameString(op, "and"))
bitAnd(bits1, bits2, chromSize);
else
bitOr(bits1, bits2, chromSize);
lmCleanup(&lm2);
}
}
slFreeList(&tdbRefList);
if (isBpWise)
{
bedMerged = bitsToBed4List(bits1, chromSize, region->chrom, 1,
region->start, region->end, lm);
if (retFieldCount != NULL)
*retFieldCount = 4;
}
else
{
struct bed *bedList1 = getRegionAsBed(db, table, region, filter,
idHash, lm, retFieldCount);
bedMerged = filterBedByOverlap(bedList1, hti->hasBlocks, op,
moreThresh, lessThresh, bits1,
chromSize);
}
bitFree(&bits1);
bitFree(&bits2);
return bedMerged;
}
}
static struct bed *intersectOnRegion(
struct sqlConnection *conn, /* Open connection to database. */
struct region *region, /* Region to work inside */
char *table1, /* Table input list is from. */
struct bed *bedList1, /* List before intersection, should be
* all within region. */
struct lm *lm, /* Local memory pool. */
int *retFieldCount) /* Field count. */
/* Intersect bed list, consulting CGI vars to figure out
* with what table and how. Return intersected result,
* which is independent from input. This potentially will
* chew up bedList1. */
{
/* Grab parameters for intersection from cart. */
double moreThresh = cartCgiUsualDouble(cart, hgtaMoreThreshold, 0);
double lessThresh = cartCgiUsualDouble(cart, hgtaLessThreshold, 100);
boolean invTable = cartCgiUsualBoolean(cart, hgtaInvertTable, FALSE);
char *op = intersectOp();
/* --- TODO MIKE - replace bedList2, bits2 with baseMask stuff. */
/* Load up intersecting bedList2 (to intersect with) */
int chromSize = hChromSize(database, region->chrom);
boolean isBpWise = (sameString("and", op) || sameString("or", op));
Bits *bits2 = bitsForIntersectingTable(conn, region, chromSize, isBpWise);
/* Set up some other local vars. */
struct hTableInfo *hti1 = getHti(database, table1, conn);
struct bed *intersectedBedList = NULL;
/* Produce intersectedBedList. */
if (isBpWise)
{
/* --- TODO MIKE - replace, bits1 with baseMask stuff. */
/* Base-pair-wise operation: get bitmap for primary table too */
Bits *bits1 = bitAlloc(chromSize+8);
boolean hasBlocks = hti1->hasBlocks;
if (retFieldCount != NULL && (*retFieldCount < 12))
hasBlocks = FALSE;
bedOrBits(bits1, chromSize, bedList1, hasBlocks, 0);
/* invert inputs if necessary */
if (invTable)
bitNot(bits1, chromSize);
/* do the intersection/union */
if (sameString("and", op))
bitAnd(bits1, bits2, chromSize);
else
bitOr(bits1, bits2, chromSize);
/* clip to region if necessary: */
if (region->start > 0)
bitClearRange(bits1, 0, region->start);
if (region->end < chromSize)
bitClearRange(bits1, region->end, (chromSize - region->end));
/* translate back to bed */
intersectedBedList = bitsToBed4List(bits1, chromSize,
region->chrom, 1, region->start, region->end, lm);
if (retFieldCount != NULL)
*retFieldCount = 4;
bitFree(&bits1);
}
else
intersectedBedList = filterBedByOverlap(bedList1, hti1->hasBlocks, op,
moreThresh, lessThresh, bits2,
chromSize);
bitFree(&bits2);
return intersectedBedList;
}
