static void getFloatArray(struct annoStreamWig *self, struct wiggle *wiggle,
boolean *retRightFail, int *retValidCount, float *vector)
/* expand wiggle bytes & spans to per-bp floats; filter values here! */
{
udcSeek(self->wibFH, wiggle->offset);
UBYTE wigBuf[wiggle->count];
size_t expectedBytes = sizeof(wigBuf);
size_t bytesRead = udcRead(self->wibFH, wigBuf, expectedBytes);
if (bytesRead != expectedBytes)
errnoAbort("annoStreamWig: failed to udcRead %llu bytes from %s (got %llu)\n",
(unsigned long long)expectedBytes, wiggle->file, (unsigned long long)bytesRead);
paranoidCheckSize(self, wiggle);
int i, j, validCount = 0;
for (i = 0; i < wiggle->count; i++)
{
float value;
if (wigBuf[i] == WIG_NO_DATA)
value = NAN;
else
{
value = BIN_TO_VALUE(wigBuf[i], wiggle->lowerLimit, wiggle->dataRange);
if (annoFilterWigValueFails(self->streamer.filters, value, retRightFail))
value = NAN;
else
validCount++;
}
int bpOffset = i * wiggle->span;
for (j = 0; j < wiggle->span; j++)
vector[bpOffset + j] = value;
}
if (retValidCount != NULL)
*retValidCount = validCount;
}
static struct wiggleData * wigReadDataRow(struct wiggle *wiggle,
int winStart, int winEnd, int tableId, boolean summaryOnly,
boolean (*wiggleCompare)(int tableId, double value,
boolean summaryOnly, struct wiggle *wiggle))
/* read one row of wiggle data, return data values between winStart, winEnd */
{
unsigned char *readData = (unsigned char *) NULL;
size_t itemsRead = 0;
int dataOffset = 0;
int noData = 0;
struct wiggleData *ret = (struct wiggleData *) NULL;
struct wiggleDatum *data = (struct wiggleDatum *)NULL;
struct wiggleDatum *dataPtr = (struct wiggleDatum *)NULL;
unsigned chromPosition = 0;
unsigned validCount = 0;
long int chromStart = -1;
unsigned chromEnd = 0;
/* limits for the complete set of data, they must change from these initial
defaults during processing */
double lowerLimit = wigEncodeStartingLowerLimit;
double upperLimit = wigEncodeStartingUpperLimit;
double sumData = 0.0;
double sumSquares = 0.0;
if (summaryOnly)
{
boolean takeIt = TRUE;
/* the 0.0 argument is unused in this case of
* summaryOnly in wiggleCompare
*/
if (wiggleCompare)
takeIt = (*wiggleCompare)(tableId, 0.0, summaryOnly, wiggle);
if (takeIt)
{
upperLimit = wiggle->lowerLimit + wiggle->dataRange;
lowerLimit = wiggle->lowerLimit;
chromStart = wiggle->chromStart;
chromEnd = wiggle->chromEnd;
validCount = wiggle->validCount;
sumData = wiggle->sumData;
sumSquares = wiggle->sumSquares;
}
}
else
{
openWibFile(wiggle->file);
fseek(wibFH, wiggle->offset, SEEK_SET);
readData = (unsigned char *) needMem((size_t) (wiggle->count + 1));
itemsRead = fread(readData, (size_t) wiggle->count,
(size_t) sizeof(unsigned char), wibFH);
if (itemsRead != sizeof(unsigned char))
errAbort("wigReadDataRow: can not read %u bytes from %s at offset %u",
wiggle->count, wiggle->file, wiggle->offset);
/* need at most this amount, perhaps less
* this data area goes with the result, this is freed by wigFreeData,
* as well as the rest of the business that goes with it in the
* returned structure */
data = (struct wiggleDatum *) needMem((size_t)
(sizeof(struct wiggleDatum)*wiggle->validCount));
dataPtr = data;
chromPosition = wiggle->chromStart;
for (dataOffset = 0; dataOffset < wiggle->count; ++dataOffset)
{
unsigned char datum = readData[dataOffset];
if (datum == WIG_NO_DATA)
++noData;
else
{
if (chromPosition >= winStart && chromPosition < winEnd)
{
double value =
BIN_TO_VALUE(datum,wiggle->lowerLimit,wiggle->dataRange);
boolean takeIt = TRUE;
if (wiggleCompare)
takeIt = (*wiggleCompare)(tableId, value, summaryOnly,
wiggle);
if (takeIt)
{
dataPtr->chromStart = chromPosition;
dataPtr->value = value;
++validCount;
if (validCount > wiggle->count)
errAbort("wigReadDataRow: validCount > wiggle->count %u > %u",
validCount, wiggle->count);
if (chromStart < 0)
chromStart = chromPosition;
chromEnd = chromPosition + wiggle->span;
if (lowerLimit > dataPtr->value)
lowerLimit = dataPtr->value;
if (upperLimit < dataPtr->value)
upperLimit = dataPtr->value;
sumData += dataPtr->value;
sumSquares += dataPtr->value * dataPtr->value;
++dataPtr;
}
}
}
chromPosition += wiggle->span;
}
freeMem(readData);
}
if (validCount)
{
double dataRange = upperLimit - lowerLimit;
AllocVar(ret);
/* this ret structure is freed by wigFreeData */
ret->next = (struct wiggleData *) NULL;
ret->chrom = wiggle->chrom;
ret->chromStart = chromStart;
ret->chromEnd = chromEnd;
ret->span = wiggle->span;
ret->count = validCount;
ret->lowerLimit = lowerLimit;
ret->dataRange = dataRange;
ret->sumData = sumData;
ret->sumSquares = sumSquares;
ret->data = data;
}
else
{
freeMem(data);
}
return (ret); /* may be null if validCount < 1 */
} /* static struct wiggleData * wigReadDataRow() */
