void bitmapToMaskArray(struct hash *bitmapHash, struct hash *tbHash)
/* Translate each bitmap in bitmapHash into an array of mask coordinates
* in the corresponding twoBit in tbHash. Assume tbHash's mask array is
* empty at the start -- we allocate it here. Free bitmap when done. */
{
struct hashCookie cookie = hashFirst(tbHash);
struct hashEl *hel = NULL;
while ((hel = hashNext(&cookie)) != NULL)
{
char *seqName = hel->name;
struct twoBit *tb = (struct twoBit *)(hel->val);
struct hashEl *bHel = hashLookup(bitmapHash, seqName);
Bits *bits;
unsigned start=0, end=0;
assert(tb != NULL);
assert(tb->maskBlockCount == 0);
if (bHel == NULL)
errAbort("Missing bitmap for seq \"%s\"", seqName);
bits = (Bits *)bHel->val;
if (bits != NULL)
{
struct lm *lm = lmInit(0);
struct unsignedRange *rangeList = NULL, *range = NULL;
int i;
for (;;)
{
start = bitFindSet(bits, end, tb->size);
if (start >= tb->size)
break;
end = bitFindClear(bits, start, tb->size);
if (end > start)
{
lmAllocVar(lm, range);
range->start = start;
range->size = (end - start);
slAddHead(&rangeList, range);
}
}
slReverse(&rangeList);
tb->maskBlockCount = slCount(rangeList);
if (tb->maskBlockCount > 0)
{
AllocArray(tb->maskStarts, tb->maskBlockCount);
AllocArray(tb->maskSizes, tb->maskBlockCount);
for (i = 0, range = rangeList; range != NULL;
i++, range = range->next)
{
tb->maskStarts[i] = range->start;
tb->maskSizes[i] = range->size;
}
}
lmCleanup(&lm);
bitFree(&bits);
bHel->val = NULL;
}
}
}
static struct bed *bitsToBed4List(Bits *bits, int bitSize,
char *chrom, int minSize, int rangeStart, int rangeEnd,
struct lm *lm)
/* Translate ranges of set bits to bed 4 items. */
{
struct bed *bedList = NULL, *bed;
boolean thisBit, lastBit;
int start = 0;
int end = 0;
int id = 0;
char name[128];
if (rangeStart < 0)
rangeStart = 0;
if (rangeEnd > bitSize)
rangeEnd = bitSize;
end = rangeStart;
/* We depend on extra zero BYTE at end in case bitNot was used on bits. */
for (;;)
{
start = bitFindSet(bits, end, rangeEnd);
if (start >= rangeEnd)
break;
end = bitFindClear(bits, start, rangeEnd);
if (end - start >= minSize)
{
lmAllocVar(lm, bed);
bed->chrom = chrom;
bed->chromStart = start;
bed->chromEnd = end;
snprintf(name, sizeof(name), "%s.%d", chrom, ++id);
bed->name = lmCloneString(lm, name);
slAddHead(&bedList, bed);
}
}
slReverse(&bedList);
return(bedList);
}
struct bbiInterval *intersectedFilteredBbiIntervalsOnRegion(struct sqlConnection *conn,
struct bbiFile *bwf, struct region *region, enum wigCompare filterCmp, double filterLl,
double filterUl, struct lm *lm)
/* Get list of bbiIntervals (more-or-less bedGraph things from bigWig) out of bigWig file
* and if necessary apply filter and intersection. Return list which is allocated in lm. */
{
char *chrom = region->chrom;
int chromSize = hChromSize(database, chrom);
struct bbiInterval *iv, *ivList = bigWigIntervalQuery(bwf, chrom, region->start, region->end, lm);
/* Run filter if necessary */
if (filterCmp != wigNoOp_e)
{
struct bbiInterval *next, *newList = NULL;
for (iv = ivList; iv != NULL; iv = next)
{
next = iv->next;
if (wigCompareValFilter(iv->val, filterCmp, filterLl, filterUl))
{
slAddHead(&newList, iv);
}
}
slReverse(&newList);
ivList = newList;
}
/* Run intersection if necessary */
if (anyIntersection())
{
boolean isBpWise = intersectionIsBpWise();
Bits *bits2 = bitsForIntersectingTable(conn, region, chromSize, isBpWise);
struct bbiInterval *next, *newList = NULL;
double moreThresh = cartCgiUsualDouble(cart, hgtaMoreThreshold, 0)*0.01;
double lessThresh = cartCgiUsualDouble(cart, hgtaLessThreshold, 100)*0.01;
char *op = cartString(cart, hgtaIntersectOp);
for (iv = ivList; iv != NULL; iv = next)
{
next = iv->next;
int start = iv->start;
int size = iv->end - start;
int overlap = bitCountRange(bits2, start, size);
if (isBpWise)
{
if (overlap == size)
{
slAddHead(&newList, iv);
}
else if (overlap > 0)
{
/* Here we have to break things up. */
double val = iv->val;
struct bbiInterval *partIv = iv; // Reuse memory for first interval
int s = iv->start, end = iv->end;
for (;;)
{
s = bitFindSet(bits2, s, end);
if (s >= end)
break;
int bitsSet = bitFindClear(bits2, s, end) - s;
if (partIv == NULL)
lmAllocVar(lm, partIv);
partIv->start = s;
partIv->end = s + bitsSet;
partIv->val = val;
slAddHead(&newList, partIv);
partIv = NULL;
s += bitsSet;
if (s >= end)
break;
}
}
}
else
{
double coverage = (double)overlap/size;
if (intersectOverlapFilter(op, moreThresh, lessThresh, coverage))
{
slAddHead(&newList, iv);
}
}
}
slReverse(&newList);
ivList = newList;
bitFree(&bits2);
}
return ivList;
}
