static void setDataValue(double val)
/* add a data value to the accumulating block of data */
{
data_values[bincount] = val;
validData[bincount] = TRUE;
++fileOffset;
++bincount; /* count scores in this bin */
/* Is it time to output a row definition ? */
if (bincount >= binsize)
output_row();
}
void wigAsciiToBinary( int argc, char *argv[] )
{
int i = 0; /* general purpose int counter */
struct lineFile *lf; /* for line file utilities */
char * fileName; /* the basename of the input file */
char *line = (char *) NULL; /* to receive data input line */
char *words[4]; /* to split data input line */
int wordCount = 0; /* result of split */
int validLines = 0; /* counting only lines with data */
unsigned long long previousOffset = 0; /* for data missing detection */
double dataValue = 0.0; /* from data input */
char *wigfile = (char *) NULL; /* file name of wiggle database file */
boolean firstInChrom; /* Is this the first line in chromosome? */
/* for each input data file */
for (i = 1; i < argc; ++i)
{
verbose(2, "translating file: %s\n", argv[i]);
fileName = basename(argv[i]);
if (name) /* Is the name of this feature specified ? */
{
safef( featureName, sizeof(featureName) - 1, "%s", name);
}
if (chrom) /* Is the chrom name specified ? */
{
chromName = cloneString(chrom);
if (! name) /* that names the feature too if not already */
safef( featureName, sizeof(featureName) - 1, "%s", chrom);
}
/* Name mangling to determine output file name */
if (wibFile) /* when specified, simply use it */
{
binfile = addSuffix(wibFile, ".wib");
wigfile = addSuffix(wibFile, ".wig");
} else { /* not specified, construct from input names */
if (startsWith("chr",fileName))
{
char *tmpString;
tmpString = cloneString(fileName);
chopSuffix(tmpString);
binfile = addSuffix(tmpString, ".wib");
wigfile = addSuffix(tmpString, ".wig");
if (! chrom) /* if not already taken care of */
chromName = cloneString(tmpString);
if (! name && ! chrom) /* if not already done */
safef(featureName, sizeof(featureName) - 1, "%s", tmpString);
freeMem(tmpString);
} else {
errAbort("Can not determine output file name, no -wibFile specified\n");
}
}
verbose(2, "output files: %s, %s\n", binfile, wigfile);
validLines = 0; /* to count only lines with data */
rowCount = 0; /* to count rows output */
bincount = 0; /* to count up to binsize */
fileOffset = 0; /* current location within binary data file */
fileOffsetBegin = 0;/* location in binary data file where this bin starts*/
firstInChrom = TRUE;
freeMem(data_values);
freeMem(validData);
data_values = needMem( (size_t) (binsize * sizeof(double)));
validData = needMem( (size_t) (binsize * sizeof(unsigned char)));
overallLowerLimit = 1.0e+300; /* for the complete set of data */
overallUpperLimit = -1.0e+300; /* for the complete set of data */
binout = mustOpen(binfile,"w"); /* binary data file */
wigout = mustOpen(wigfile,"w"); /* table row definition file */
lf = lineFileOpen(argv[i], TRUE); /* input file */
while (lineFileNextReal(lf, &line))
{
boolean readingFrameSlipped;
char *valEnd;
char *val;
++validLines;
wordCount = chopByWhite(line, words, ArraySize(words));
if (wordCount == 1)
{
Offset += 1;
val = words[0];
}
else if (wordCount == 2)
{
Offset = atoll(words[0]) - 1;
val = words[1];
}
else if (wordCount == 3)
{
char *newChrom = words[0];
boolean sameChrom = (chromName == NULL || sameString(chromName, newChrom));
Offset = atoll(words[1]) - 1;
val = words[2];
if (!sameChrom)
{
output_row();
firstInChrom = TRUE;
freez(&chromName);
}
if (chromName == NULL)
chromName = cloneString(newChrom);
}
else
{
val = NULL;
badFormat(lf);
}
if (Offset < 0)
errAbort("Illegal offset %llu at line %d of %s", Offset+1, lf->lineIx,
lf->fileName);
dataValue = strtod(val, &valEnd);
if(trimVals)
{
dataValue = max(minVal, dataValue);
dataValue = min(maxVal, dataValue);
}
if ((*val == '\0') || (*valEnd != '\0'))
errAbort("Not a valid float at line %d: %s\n", lf->lineIx, val);
/* see if this is the first time through, establish chromStart */
if (firstInChrom) {
chromStart = Offset;
verbose(2, "first offset: %llu\n", chromStart);
}
else if (!firstInChrom && (Offset <= previousOffset))
errAbort("ERROR: chrom positions not in order. line %d of %s\n"
"previous: %llu >= %llu <-current",
lf->lineIx, lf->fileName, previousOffset+1, Offset+1);
/* if we are working on a zoom level and the data is not exactly
* spaced according to the span, then we need to put each value
* in its own row in order to keep positioning correct for these
* data values. The number of skipped bases has to be an even
* multiple of dataSpan
*/
readingFrameSlipped = FALSE;
if (!firstInChrom && (dataSpan > 1))
{
int skippedBases;
int spansSkipped;
skippedBases = Offset - previousOffset;
spansSkipped = skippedBases / dataSpan;
if ((spansSkipped * dataSpan) != skippedBases)
readingFrameSlipped = TRUE;
}
if (readingFrameSlipped)
{
verbose(2, "data not spanning %llu bases, prev: %llu, this: %llu, at line: %d\n", dataSpan, previousOffset, Offset, lf->lineIx);
output_row();
chromStart = Offset; /* a full reset here */
}
/* Check to see if data is being skipped */
else if ( (!firstInChrom) && (Offset > (previousOffset + dataSpan)) )
{
unsigned long long off;
unsigned long long fillSize; /* number of bytes */
verbose(2, "missing data offsets: %llu - %llu\n",
previousOffset+1,Offset-1);
/* If we are just going to fill the rest of this bin with
* no data, then may as well stop here. No need to fill
* it with nothing.
*/
fillSize = (Offset - (previousOffset + dataSpan)) / dataSpan;
verbose(2, "filling NO_DATA for %llu bytes at bincount: %llu\n", fillSize, bincount);
if (fillSize + bincount >= binsize)
{
verbose(2, "completing a bin due to NO_DATA for %llu bytes, only %llu - %llu = %llu to go\n", fillSize, binsize, bincount, binsize - bincount);
verbose(2, "Offset: %llu, previousOffset: %llu\n",
Offset, previousOffset);
output_row();
chromStart = Offset; /* a full reset here */
} else {
fillSize = 0;
/* fill missing data with NO_DATA indication */
for (off = previousOffset + dataSpan; off < Offset;
off += dataSpan)
{
++fillSize;
++fileOffset;
++bincount; /* count scores in this bin */
if (bincount >= binsize) break;
}
verbose(2, "filled NO_DATA for %llu bytes at bincount: %llu\n", fillSize, bincount);
/* If that finished off this bin, output it
* This most likely should not happen here. The
* check above: if (fillSize + bincount >= binsize)
* should have caught this case already.
*/
if (bincount >= binsize)
{
output_row();
chromStart = Offset; /* a full reset here */
}
}
}
/* With perhaps the missing data taken care of, back to the
* real data.
*/
data_values[bincount] = dataValue;
validData[bincount] = TRUE;
++fileOffset;
++bincount; /* count scores in this bin */
/* Is it time to output a row definition ? */
if (bincount >= binsize)
{
output_row();
}
previousOffset = Offset;
firstInChrom = FALSE;
} /* reading file input loop end */
/* Done with input file, any data points left in this bin ? */
if (bincount)
{
output_row();
}
verbose(2, "fini: %s, read %d lines, table rows: %llu, data bytes: %lld\n",
argv[i], lf->lineIx, rowCount, fileOffset);
verbose(1, "data limits: [%g:%g], range: %g\n",
overallLowerLimit, overallUpperLimit,
overallUpperLimit - overallLowerLimit);
lineFileClose(&lf);
fclose(binout);
fclose(wigout);
freeMem(binfile);
freeMem(wigfile);
freeMem(chromName);
binfile = (char *) NULL;
wigfile = (char *) NULL;
chromName = (char *) NULL;
}
return;
}
/*
* PQprint()
*
* Format results of a query for printing.
*
* PQprintOpt is a typedef (structure) that contains
* various flags and options. consult libpq-fe.h for
* details
*
* This function should probably be removed sometime since psql
* doesn't use it anymore. It is unclear to what extent this is used
* by external clients, however.
*/
void
PQprint(FILE *fout, const PGresult *res, const PQprintOpt *po)
{
int nFields;
nFields = PQnfields(res);
if (nFields > 0)
{ /* only print rows with at least 1 field. */
int i,
j;
int nTups;
int *fieldMax = NULL; /* in case we don't use them */
unsigned char *fieldNotNum = NULL;
char *border = NULL;
char **fields = NULL;
const char **fieldNames;
int fieldMaxLen = 0;
int numFieldName;
int fs_len = strlen(po->fieldSep);
int total_line_length = 0;
int usePipe = 0;
char *pagerenv;
#if defined(ENABLE_THREAD_SAFETY) && !defined(WIN32)
sigset_t osigset;
bool sigpipe_masked = false;
bool sigpipe_pending;
#endif
#if !defined(ENABLE_THREAD_SAFETY) && !defined(WIN32)
pqsigfunc oldsigpipehandler = NULL;
#endif
#ifdef TIOCGWINSZ
struct winsize screen_size;
#else
struct winsize
{
int ws_row;
int ws_col;
} screen_size;
#endif
nTups = PQntuples(res);
if (!(fieldNames = (const char **) calloc(nFields, sizeof(char *))))
{
fprintf(stderr, libpq_gettext("out of memory\n"));
abort();
}
if (!(fieldNotNum = (unsigned char *) calloc(nFields, 1)))
{
fprintf(stderr, libpq_gettext("out of memory\n"));
abort();
}
if (!(fieldMax = (int *) calloc(nFields, sizeof(int))))
{
fprintf(stderr, libpq_gettext("out of memory\n"));
abort();
}
for (numFieldName = 0;
po->fieldName && po->fieldName[numFieldName];
numFieldName++)
;
for (j = 0; j < nFields; j++)
{
int len;
const char *s = (j < numFieldName && po->fieldName[j][0]) ?
po->fieldName[j] : PQfname(res, j);
fieldNames[j] = s;
len = s ? strlen(s) : 0;
fieldMax[j] = len;
len += fs_len;
if (len > fieldMaxLen)
fieldMaxLen = len;
total_line_length += len;
}
total_line_length += nFields * strlen(po->fieldSep) + 1;
if (fout == NULL)
fout = stdout;
if (po->pager && fout == stdout && isatty(fileno(stdin)) &&
isatty(fileno(stdout)))
{
/*
* If we think there'll be more than one screen of output, try to
* pipe to the pager program.
*/
#ifdef TIOCGWINSZ
if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) == -1 ||
screen_size.ws_col == 0 ||
screen_size.ws_row == 0)
{
screen_size.ws_row = 24;
screen_size.ws_col = 80;
}
#else
screen_size.ws_row = 24;
screen_size.ws_col = 80;
#endif
pagerenv = getenv("PAGER");
if (pagerenv != NULL &&
pagerenv[0] != '\0' &&
!po->html3 &&
((po->expanded &&
nTups * (nFields + 1) >= screen_size.ws_row) ||
(!po->expanded &&
nTups * (total_line_length / screen_size.ws_col + 1) *
(1 + (po->standard != 0)) >= screen_size.ws_row -
(po->header != 0) *
(total_line_length / screen_size.ws_col + 1) * 2
- (po->header != 0) * 2 /* row count and newline */
)))
{
fout = popen(pagerenv, "w");
if (fout)
{
usePipe = 1;
#ifndef WIN32
#ifdef ENABLE_THREAD_SAFETY
if (pq_block_sigpipe(&osigset, &sigpipe_pending) == 0)
sigpipe_masked = true;
#else
oldsigpipehandler = pqsignal(SIGPIPE, SIG_IGN);
#endif /* ENABLE_THREAD_SAFETY */
#endif /* WIN32 */
}
else
fout = stdout;
}
}
if (!po->expanded && (po->align || po->html3))
{
if (!(fields = (char **) calloc(nFields * (nTups + 1), sizeof(char *))))
{
fprintf(stderr, libpq_gettext("out of memory\n"));
abort();
}
}
else if (po->header && !po->html3)
{
if (po->expanded)
{
if (po->align)
fprintf(fout, libpq_gettext("%-*s%s Value\n"),
fieldMaxLen - fs_len, libpq_gettext("Field"), po->fieldSep);
else
fprintf(fout, libpq_gettext("%s%sValue\n"), libpq_gettext("Field"), po->fieldSep);
}
else
{
int len = 0;
for (j = 0; j < nFields; j++)
{
const char *s = fieldNames[j];
fputs(s, fout);
len += strlen(s) + fs_len;
if ((j + 1) < nFields)
fputs(po->fieldSep, fout);
}
fputc('\n', fout);
for (len -= fs_len; len--; fputc('-', fout));
fputc('\n', fout);
}
}
if (po->expanded && po->html3)
{
if (po->caption)
fprintf(fout, "<center><h2>%s</h2></center>\n", po->caption);
else
fprintf(fout,
"<center><h2>"
"Query retrieved %d rows * %d fields"
"</h2></center>\n",
nTups, nFields);
}
for (i = 0; i < nTups; i++)
{
if (po->expanded)
{
if (po->html3)
fprintf(fout,
"<table %s><caption align=\"top\">%d</caption>\n",
po->tableOpt ? po->tableOpt : "", i);
else
fprintf(fout, libpq_gettext("-- RECORD %d --\n"), i);
}
for (j = 0; j < nFields; j++)
do_field(po, res, i, j, fs_len, fields, nFields,
fieldNames, fieldNotNum,
fieldMax, fieldMaxLen, fout);
if (po->html3 && po->expanded)
fputs("</table>\n", fout);
}
if (!po->expanded && (po->align || po->html3))
{
if (po->html3)
{
if (po->header)
{
if (po->caption)
fprintf(fout,
"<table %s><caption align=\"top\">%s</caption>\n",
po->tableOpt ? po->tableOpt : "",
po->caption);
else
fprintf(fout,
"<table %s><caption align=\"top\">"
"Retrieved %d rows * %d fields"
"</caption>\n",
po->tableOpt ? po->tableOpt : "", nTups, nFields);
}
else
fprintf(fout, "<table %s>", po->tableOpt ? po->tableOpt : "");
}
if (po->header)
border = do_header(fout, po, nFields, fieldMax, fieldNames,
fieldNotNum, fs_len, res);
for (i = 0; i < nTups; i++)
output_row(fout, po, nFields, fields,
fieldNotNum, fieldMax, border, i);
free(fields);
if (border)
free(border);
}
if (po->header && !po->html3)
fprintf(fout, "(%d row%s)\n\n", PQntuples(res),
(PQntuples(res) == 1) ? "" : "s");
free(fieldMax);
free(fieldNotNum);
free((void *) fieldNames);
if (usePipe)
{
#ifdef WIN32
_pclose(fout);
#else
pclose(fout);
#ifdef ENABLE_THREAD_SAFETY
/* we can't easily verify if EPIPE occurred, so say it did */
if (sigpipe_masked)
pq_reset_sigpipe(&osigset, sigpipe_pending, true);
#else
pqsignal(SIGPIPE, oldsigpipehandler);
#endif /* ENABLE_THREAD_SAFETY */
#endif /* WIN32 */
}
if (po->html3 && !po->expanded)
fputs("</table>\n", fout);
}
}
/* The single externally visible routine.
* Future improvements will need to add a couple more arguments to
* satisify the needs of the command line version and its options.
* Currently, this is used only in customTrack input parsing.
*/
void wigAsciiToBinary( char *wigAscii, char *wigFile, char *wibFile,
double *upperLimit, double *lowerLimit, struct wigEncodeOptions *options)
/* given the three file names, read the ascii wigAscii file and produce
* the wigFile and wibFile outputs
*/
{
struct lineFile *lf; /* for line file utilities */
char *line = (char *) NULL; /* to receive data input line */
char *words[10]; /* to split data input line */
int wordCount = 0; /* result of split */
int validLines = 0; /* counting only lines with data */
double dataValue = 0.0; /* from data input */
boolean bedData = FALSE; /* in bed format data */
boolean variableStep = FALSE; /* in variableStep data */
boolean fixedStep = FALSE; /* in fixedStep data */
char *prevChromName = (char *)NULL; /* to watch for chrom name changes */
int trackCount = 0; /* We abort if we see more than one track. */
if ((wigAscii == (char *)NULL) || (wigFile == (char *)NULL) ||
(wibFile == (char *)NULL))
errAbort("wigAsciiToBinary: missing data file names, ascii: %s, wig: %s, wib: %s", wigAscii, wigFile, wibFile);
/* need to be careful here and initialize all the global variables */
freez(&wibFileName); /* send this name to the global */
wibFileName = cloneString(wibFile); /* variable for use in output_row() */
lineCount = 0; /* to count all lines */
add_offset = 0; /* to allow "lifting" of the data */
validLines = 0; /* to count only lines with data */
rowCount = 0; /* to count rows output */
bincount = 0; /* to count up to binsize */
binsize = 1024; /* # of data points per table row */
dataSpan = 1; /* default bases spanned per data point */
chromStart = 0; /* for table row data */
previousOffset = 0; /* for data missing detection */
fileOffset = 0; /* current location within binary data file */
fileOffsetBegin = 0;/* location in binary data file where this bin starts*/
freez(&data_values);
freez(&validData);
data_values = (double *) needMem( (size_t) (binsize * sizeof(double)));
validData = (unsigned char *)
needMem( (size_t) (binsize * sizeof(unsigned char)));
if (options != NULL)
{
if (options->lift != 0)
add_offset = options->lift;
if (options->noOverlap)
noOverlap = TRUE;
if (options->flagOverlapSpanData)
flagOverlapSpanData = TRUE;
if (options->wibSizeLimit > 0)
wibSizeLimit = options->wibSizeLimit;
}
/* limits for the complete set of data, they must change from these initial
defaults during processing */
overallLowerLimit = wigEncodeStartingLowerLimit;
overallUpperLimit = wigEncodeStartingUpperLimit;
binout = mustOpen(wibFile,"w"); /* binary data file */
wigout = mustOpen(wigFile,"w"); /* table row definition file */
#if defined(DEBUG) /* dbg */
chmod(wibFile, 0666);
chmod(wigFile, 0666);
#endif
lf = lineFileOpen(wigAscii, TRUE); /* input file */
while (lineFileNext(lf, &line, NULL))
{
boolean readingFrameSlipped;
++lineCount;
if ((wibSizeLimit > 0) && (wibSize >= wibSizeLimit))
errAbort("data size limit of %lld data values has been exceeded. This data can be efficiently displayed with the <A HREF='/goldenPath/help/bigWig.html' TARGET=_blank>bigWig file format</A> in a custom track, or in a <A HREF='/goldenPath/help/hgTrackHubHelp.html' TARGET=_blank>Track Hub</A> for multiple large datasets.", wibSizeLimit);
line = skipLeadingSpaces(line);
/* ignore blank or comment lines */
if ((line == (char *)NULL) || (line[0] == '\0') || (line[0] == '#'))
continue; /* !!! go to next line of input */
wordCount = chopByWhite(line, words, ArraySize(words));
if (sameWord("track",words[0]))
{
/* Allow (and ignore) one track line, but no more. */
++trackCount;
if (trackCount > 1)
errAbort("Multiple tracks seen, second at line %d of %s, can only handle one.",
lf->lineIx, lf->fileName);
continue;
}
else if (sameWord("browser", words[0]))
{
continue; /* ignore browser lines if present */
}
else if (sameWord("variableStep",words[0]))
{
int i;
boolean foundChrom = FALSE;
/* safest thing to do if we were processing anything is to
* output that previous block and start anew
* Future improvement could get fancy here and decide if it
* is really necessary to start over, although the concept
* of a line between data points on one item may use this
* block behavior later to define line segments, so don't
* get too quick to be fancy here. This line behavior
* implies that feature names will need to be specified to
* identify the line segments that belong together.
*/
if (variableStep || bedData || fixedStep)
{
output_row();
validLines = 0; /* to cause reset for first offset */
}
dataSpan = 1; /* default bases spanned per data point */
for(i = 1; i < wordCount; ++i)
{
if (startsWith("chrom",words[i]))
{
setChromName(words[i]);
foundChrom = TRUE;
}
else if (startsWith("span",words[i]))
setDataSpan(words[i]);
else
errAbort("illegal specification on variableStep at line %lu: %s",
lineCount, words[i]);
}
if (!foundChrom)
errAbort("missing chrom=<name> specification on variableStep declaration at line %lu", lineCount);
variableStep = TRUE;
bedData = FALSE;
fixedStep = FALSE;
freez(&prevChromName);
prevChromName = cloneString(chromName);
continue; /* !!! go to next input line */
}
else if (sameWord("fixedStep",words[0]))
{
boolean foundChrom = FALSE;
boolean foundStart = FALSE;
int i;
/* same comment as above */
if (variableStep || bedData || fixedStep)
{
output_row();
validLines = 0; /* to cause reset for first offset */
}
stepSize = 1; /* default step size */
dataSpan = 0; /* this will match step size if not set*/
for(i = 1; i < wordCount; ++i)
{
if (startsWith("chrom",words[i]))
{
setChromName(words[i]);
foundChrom = TRUE;
}
else if (startsWith("start",words[i]))
{
setFixedStart(words[i]);
foundStart = TRUE;
}
else if (startsWith("step",words[i]))
setStepSize(words[i]);
else if (startsWith("span",words[i]))
setDataSpan(words[i]);
else
errAbort("illegal specification on variableStep at line %lu: %s",
lineCount, words[i]);
}
if (dataSpan == 0)
dataSpan = stepSize;
if (!foundChrom)
errAbort("missing chrom=<name> specification on fixedStep declaration at line %lu", lineCount);
if (!foundStart)
errAbort("missing start=<position> specification on fixedStep declaration at line %lu", lineCount);
if (noOverlap && validLines && prevChromName)
{
if (sameWord(prevChromName,chromName) && (fixedStart < chromStart))
errAbort("specified fixedStep chromStart %llu is less than expected next chromStart %llu", fixedStart, chromStart);
}
variableStep = FALSE;
bedData = FALSE;
fixedStep = TRUE;
freez(&prevChromName);
prevChromName = cloneString(chromName);
continue; /* !!! go to next input line */
}
else if (wordCount == 4)
{
/* while in bedData, we do not necessarily need to start a new
* batch unless the chrom name is changing, since dataSpan
* is always 1 for bedData. As above, this may change in
* the future if each bed line specification is talking
* about a different feature.
*/
if (variableStep || fixedStep ||
(bedData && ((prevChromName != (char *)NULL) &&
differentWord(prevChromName,words[0]))))
{
output_row();
validLines = 0; /* to cause reset for first offset */
}
dataSpan = 1; /* default bases spanned per data point */
variableStep = FALSE;
bedData = TRUE;
fixedStep = FALSE;
freez(&chromName);
chromName=cloneString(words[0]);
freez(&featureName);
featureName=cloneString(words[0]);
bedChromStart = sqlLongLong(words[1]);
bedChromEnd = sqlLongLong(words[2]);
bedDataValue = sqlDouble(words[3]);
/* the bed format coordinate system is zero relative, half-open,
* hence, no adjustment of bedChromStart is needed here, unlike the
* fixed and variable step formats which will subtract one from the
* incoming coordinate.
*/
if (bedChromStart >= bedChromEnd)
errAbort("Found chromStart >= chromEnd at line %lu (%llu > %llu)",
lineCount, bedChromStart, bedChromEnd);
if (bedChromEnd > (bedChromStart + 10000000))
errAbort("Limit of 10,000,000 length specification for bed format at line %lu, found: %llu)",
lineCount, bedChromEnd-bedChromStart);
if ((validLines > 0) && (bedChromStart < previousOffset))
errAbort("chrom positions not in numerical order at line %lu. previous: %llu > %llu <-current (bed)", lineCount, previousOffset, bedChromStart);
freez(&prevChromName);
prevChromName = cloneString(chromName);
}
/* We must be in one of these data formats at this point */
if (!(variableStep || fixedStep || bedData))
errAbort("at the line beginning: %s, variableStep or fixedStep data declaration not found or BED data 4 column format not recognized.", words[0]);
if (variableStep && (wordCount != 2))
errAbort("Expecting two words for variableStep data at line %lu, found %d",
lineCount, wordCount);
if (fixedStep && (wordCount != 1))
errAbort("Expecting one word for fixedStep data at line %lu, found %d",
lineCount, wordCount);
if (bedData && (wordCount != 4))
errAbort("Expecting four words for bed format data at line %lu, found %d",
lineCount, wordCount);
++validLines; /* counting good lines of data input */
/* Offset is the incoming specified position for this value,
* fixedStart has already been converted to zero
* relative half open
*/
if (variableStep)
{
Offset = sqlLongLong(words[0]);
Offset = BASE_0(Offset); /* zero relative half open */
dataValue = sqlDouble(words[1]);
}
else if (fixedStep)
{
Offset = fixedStart + (stepSize * (validLines - 1));
dataValue = sqlDouble(words[0]);
}
else if (bedData)
{
Offset = bedChromStart;
dataValue = bedDataValue;
}
if (dataValue > overallUpperLimit) overallUpperLimit = dataValue;
if (dataValue < overallLowerLimit) overallLowerLimit = dataValue;
/* see if this is the first time through, establish chromStart */
if (validLines == 1)
{
chromStart = Offset;
verbose(2, "first offset: %llu\n", chromStart);
}
else if ((validLines > 1) && (Offset <= previousOffset))
errAbort("chrom positions not in numerical order at line %lu. previous: %llu > %llu "
"<-current (offset)", lineCount, BASE_1(previousOffset), BASE_1(Offset));
/* if we are working on a zoom level and the data is not exactly
* spaced according to the span, then we need to put each value
* in its own row in order to keep positioning correct for these
* data values. The number of skipped bases has to be an even
* multiple of dataSpan
*/
readingFrameSlipped = FALSE;
if ((validLines > 1) && (dataSpan > 1))
{
unsigned long long prevEnd = previousOffset + dataSpan;
int skippedBases;
int spansSkipped;
skippedBases = Offset - previousOffset;
if (flagOverlapSpanData && (prevEnd > Offset))
errAbort("ERROR: data points overlapping at input line %lu.\n"
"previous data point position: %s:%llu-%llu overlaps current: %s:%llu-%llu",
lineCount, chromName, BASE_1(previousOffset), prevEnd,
chromName, BASE_1(Offset),Offset+dataSpan);
spansSkipped = skippedBases / dataSpan;
if ((spansSkipped * dataSpan) != skippedBases)
readingFrameSlipped = TRUE;
}
if (readingFrameSlipped)
{
verbose(2, "data not spanning %llu bases, prev: %llu, this: %llu, at line: %lu\n", dataSpan, previousOffset, Offset, lineCount);
output_row();
chromStart = Offset; /* a full reset here */
}
/* Check to see if data is being skipped */
else if ( (validLines > 1) && (Offset > (previousOffset + dataSpan)) )
{
unsigned long long off;
unsigned long long fillSize; /* number of bytes */
verbose(2, "missing data offsets: %llu - %llu\n",
BASE_1(previousOffset),BASE_0(Offset));
/* If we are just going to fill the rest of this bin with
* no data, then may as well stop here. No need to fill
* it with nothing.
*/
fillSize = (Offset - (previousOffset + dataSpan)) / dataSpan;
verbose(2, "filling NO_DATA for %llu bytes\n", fillSize);
if (fillSize + bincount >= binsize)
{
verbose(2, "completing a bin due to NO_DATA for %llu bytes, only %llu - %llu = %llu to go\n", fillSize, binsize, bincount, binsize - bincount);
verbose(2, "Offset: %llu, previousOffset: %llu\n",
Offset, previousOffset);
output_row();
chromStart = Offset; /* a full reset here */
} else {
fillSize = 0;
/* fill missing data with NO_DATA indication */
for (off = previousOffset + dataSpan; off < Offset;
off += dataSpan)
{
++fillSize;
++fileOffset;
++bincount; /* count scores in this bin */
if (bincount >= binsize) break;
}
verbose(2, "filled NO_DATA for %llu bytes\n", fillSize);
/* If that finished off this bin, output it
* This most likely should not happen here. The
* check above: if (fillSize + bincount >= binsize)
* should have caught this case already.
*/
if (bincount >= binsize)
{
output_row();
chromStart = Offset; /* a full reset here */
}
}
}
/* With perhaps the missing data taken care of, back to the
* real data.
*/
if (bedData)
{
unsigned long long bedSize = bedChromEnd - bedChromStart;
for ( ; bedSize > 0; --bedSize )
{
setDataValue(bedDataValue);
Offset += 1;
}
Offset -= 1; /* loop above increments this one too much.
* This Offset is supposed to be the last
* valid chrom position written, not the
* next to be written */
}
else
{
setDataValue(dataValue);
}
previousOffset = Offset; /* remember position for gap calculations */
} /* reading file input loop end */
/* Done with input file, any data points left in this bin ? */
if (bincount)
output_row();
lineFileClose(&lf);
fclose(binout);
fclose(wigout);
freez(&chromName);
freez(&featureName);
freez(&data_values);
freez(&validData);
freez(&wibFileName);
/* return limits if pointers are given */
if (upperLimit)
*upperLimit = overallUpperLimit;
if (lowerLimit)
*lowerLimit = overallLowerLimit;
if (wibSizeLimit > 0)
options->wibSizeLimit = wibSize;
}
