void explainSome(char *database, Bits *h**o, Bits *once, Bits *bits, char *chrom, int chromSize,
struct sqlConnection *conn, char *trackSpec, char *homologyTrack)
/* Explain some of homology. */
{
int trackSize = 0, homoSize = 0, andSize = 0, cumSize = 0, newSize = 0;
homoSize = bitCountRange(h**o, 0, chromSize);
bitClear(bits, chromSize);
if (trackSpec != NULL)
{
fbOrTableBits(database, bits, trackSpec, chrom, chromSize, conn);
trackSize = bitCountRange(bits, 0, chromSize);
bitAnd(bits, h**o, chromSize);
andSize = bitCountRange(bits, 0, chromSize);
bitAnd(bits, once, chromSize);
newSize = bitCountRange(bits, 0, chromSize);
bitNot(bits, chromSize);
bitAnd(once, bits, chromSize);
cumSize = homoSize - bitCountRange(once, 0, chromSize);
}
else
{
trackSpec = homologyTrack;
trackSize = andSize = homoSize;
cumSize = newSize = 0;
}
printf("%-21s %8d %8d %5.2f%% %6.2f%% %6.2f%% %5.2f%% %5.2f%%\n",
trackSpec, trackSize, andSize,
100.0*trackSize/chromSize,
100.0*andSize/trackSize,
100.0*andSize/homoSize,
100.0*newSize/homoSize,
100.0*cumSize/homoSize);
}
void MPG::searchPacks(){
packs = (pack *)malloc(buf_size / 128);
packs_size = 0;
const BYTE *i;
BYTE z1[10];
BYTE z2[10];
const BYTE *last = memsearch(buf, buf_size, CODE_PACK, 4);
std::cout << "first pack : " << (last - buf) << std::endl;
while (1) {
i = memsearch(last+1, (buf_end-last) + 1, CODE_PACK, 4);
if (i == NULL) break;
// classify pack
bitAnd(last+4, (const BYTE *)MPG1_PACK_MASK, z1, 10);
bitAnd(last+4, (const BYTE *)MPG2_PACK_MASK, z2, 10);
if(memcmp(z1, MPG1_PACK_HEAD, 10)==0){
pack p = {last+12, i-1, i-(last+12)};
packs[packs_size++] = p;
}
else if(memcmp(z2,MPG2_PACK_HEAD, 10)==0){
pack p = {last+14, i-1, i-(last+14)};
packs[packs_size++] = p;
}
last = i;
}
// for last pack (bigger than 30bytes)
if (buf_end - last > 30) {
bitAnd(last+4, (const BYTE *)MPG1_PACK_MASK, z1, 10);
bitAnd(last+4, (const BYTE *)MPG2_PACK_MASK, z2, 10);
if(memcmp(z1, MPG1_PACK_HEAD, 10) == 0){
pack p = {last+12, buf_end, buf_end-(last+12) + 1};
packs[packs_size++] = p;
}
else if(memcmp(z2, MPG2_PACK_HEAD, 10) == 0){
pack p = {last+14, buf_end, buf_end-(last+14) + 1};
packs[packs_size++] = p;
}
}
std::cout << "packs num : " << packs_size << std::endl;
}
void intersectOnChrom(char *db, struct sqlConnection *conn, char *chrom,
char *track1, char *track2)
/* Do intersection on one chromosome. */
{
int chromSize = hChromSize(chrom);
struct lm *lm = lmInit(0);
struct bed *bedList1, *bedList2, *andBed;
struct featureBits *fb1, *fb2;
Bits *bit1, *bit2;
int fieldCount1, fieldCount2;
struct binKeeper *bk2;
uglyTime(NULL);
scanChromTable(conn, chrom, track1);
scanChromTable(conn, chrom, track2);
uglyTime("Scan tracks");
bedList1 = getChromAsBed(conn, db, track1, chrom, lm, &fieldCount1);
bedList2 = getChromAsBed(conn, db, track2, chrom, lm, &fieldCount2);
uglyTime("Tracks as bed");
uglyf("%d items with %d fields in %s, ", slCount(bedList1), fieldCount1, track1);
uglyf("%d items with %d fields in %s\n", slCount(bedList2), fieldCount2, track2);
bit1 = bitAlloc(chromSize+8);
bit2 = bitAlloc(chromSize+8);
uglyTime("bitAlloc");
fb1 = fbList(db, chrom, track1, bedList1, chromSize);
fb2 = fbList(db, chrom, track1, bedList1, chromSize);
uglyTime("bed to featureBits list");
fbOrBits(bit1, chromSize, fb1, 0);
fbOrBits(bit2, chromSize, fb2, 0);
uglyTime("or into bits");
bitAnd(bit1, bit2, chromSize);
uglyTime("Anding bitfields");
andBed = bitsToBed4List(bit1, chromSize, chrom, 0, 0, chromSize, lm);
uglyTime("Converting bitfield to bed 4");
bitCountAllOverlaps(bedList1, bit2, fieldCount2);
uglyTime("Counting overlaps in track1 with bitfield of track2");
bk2 = fbToBinKeeper(fb2, chromSize);
uglyTime("Adding featureBits list from track 2 into binKeeper.");
bkCountAllOverlaps(bedList1, bk2, fieldCount2);
uglyTime("Count overlaps in track1 with binKeeper of track2");
featureBitsFreeList(&fb1);
featureBitsFreeList(&fb2);
uglyTime("free featureBits");
bitFree(&bit1);
bitFree(&bit2);
uglyTime("bitFree");
}
void statsOnSpan(char *database, struct sqlConnection *conn, struct region *r,
char *axtBestDir, struct stats *stats, FILE *f,
struct scoredWindow **pWinList)
/* Gather region info on one chromosome/region. */
{
char *chrom = r->chrom;
int chromSize = hChromSize(database, chrom);
Bits *maskBits = bitAlloc(chromSize);
Bits *aliBits = bitAlloc(chromSize);
Bits *matchBits = bitAlloc(chromSize);
Bits *geneBits = bitAlloc(chromSize);
/* Set up aliBits and matchBits for to be turned on
* where bases align, and where bases align and match.
* Zero both bitmaps in areas that are transcribed. */
setAliBits(axtBestDir, chrom, chromSize, aliBits, matchBits);
maskFeatures(database, conn, chrom, chromSize, maskBits);
bitNot(maskBits, chromSize);
bitAnd(aliBits, maskBits, chromSize);
bitAnd(matchBits, maskBits, chromSize);
/* Set up maskBits to have 0's on gaps in genome */
bitClear(maskBits, chromSize);
fbOrTableBits(database, maskBits, "gap", chrom, chromSize, conn);
bitNot(maskBits, chromSize);
/* Set up bitmap for Ensemble or mRNA. */
fbOrTableBits(database, geneBits, "ensGene", chrom, chromSize, conn);
fbOrTableBits(database, geneBits, "mrna", chrom, chromSize, conn);
/* Calculate various stats on windows. */
addToStats(stats, aliBits, matchBits, geneBits, maskBits, r, f, pWinList);
/* Cleanup */
bitFree(&geneBits);
bitFree(&maskBits);
bitFree(&aliBits);
bitFree(&matchBits);
}
int main() {
printf("Test with main.\n");
printf("bitAnd Result: %d\n", bitAnd(15,3));
printf("getByte Result: %d \n",getByte(0x12345678,22));
printf("bitcount Result: %d \n", bitCount(1));
printf("bang result is: %d \n", bang(3));
printf("minimum two's complement integer is: %d \n",tmin());
printf("fitbits result is: %d \n",fitsBits(-4,3));
printf("divpwr2 result is: %d \n",divpwr2(-33,4));
printf("negate result is: %d \n",negate(4));
printf("isPositive result is: %d \n",isPositive(-4));
printf("isLessOrEqual result is: %d \n",isLessOrEqual(5,5));
printf("float_neg result is: %d \n",float_neg(13));
printf("float_i2f result is: %d \n",float_i2f(15));
printf("float_twice result is: %d \n",float_twice(9.84));
}
void chromFeatureBits(struct sqlConnection *conn,char *database,
char *chrom, int tableCount, char *tables[],
FILE *bedFile, FILE *faFile, FILE *binFile,
struct bed *bedRegionList, FILE *bedOutFile,
int chromSize, int *retChromBits,
int *retFirstTableBits, int *retSecondTableBits)
/* featureBits - Correlate tables via bitmap projections and booleans
* on one chromosome. */
{
int i;
Bits *acc = NULL;
Bits *bits = NULL;
char *table;
acc = bitAlloc(chromSize);
bits = bitAlloc(chromSize);
for (i=0; i<tableCount; ++i)
{
boolean not = FALSE;
table = tables[i];
if (table[0] == '!')
{
not = TRUE;
++table;
}
if (i == 0)
{
orTable(database, acc, table, chrom, chromSize, conn);
if (not)
bitNot(acc, chromSize);
if (retFirstTableBits != NULL)
*retFirstTableBits = bitCountRange(acc, 0, chromSize);
}
else
{
bitClear(bits, chromSize);
orTable(database, bits, table, chrom, chromSize, conn);
if (not)
bitNot(bits, chromSize);
if (i == 1 && retSecondTableBits != NULL)
*retSecondTableBits = bitCountRange(bits, 0, chromSize);
/* feature/bug - the above does not respect minSize */
if (orLogic)
bitOr(acc, bits, chromSize);
else
bitAnd(acc, bits, chromSize);
}
}
if (notResults)
bitNot(acc, chromSize);
*retChromBits = bitCountRange(acc, 0, chromSize);
if (bedFile != NULL || faFile != NULL)
{
minSize = optionInt("minSize", minSize);
bitsToBed(database, acc, chrom, chromSize, bedFile, faFile, minSize);
}
if (binFile != NULL)
{
binSize = optionInt("binSize", binSize);
binOverlap = optionInt("binOverlap", binOverlap);
bitsToBins(acc, chrom, chromSize, binFile, binSize, binOverlap);
}
if (bedOutFile != NULL)
bitsToRegions(acc, chrom, chromSize, bedRegionList, bedOutFile);
bitFree(&acc);
bitFree(&bits);
}
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;
}