int
unrrdu_dataMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
hestOpt *opt = NULL;
char *err, *inS=NULL;
Nrrd *nin;
NrrdIoState *nio;
airArray *mop;
int car, pret;
mop = airMopNew();
hestOptAdd(&opt, NULL, "nin", airTypeString, 1, 1, &inS, NULL,
"input nrrd");
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_dataInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
nio = nrrdIoStateNew();
airMopAdd(mop, nio, (airMopper)nrrdIoStateNix, airMopAlways);
nio->skipData = AIR_TRUE;
nio->keepNrrdDataFileOpen = AIR_TRUE;
nin = nrrdNew();
airMopAdd(mop, nin, (airMopper)nrrdNuke, airMopAlways);
if (nrrdLoad(nin, inS, nio)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error reading header:\n%s", me, err);
airMopError(mop);
return 1;
}
if (_nrrdDataFNNumber(nio) > 1) {
fprintf(stderr, "%s: sorry, currently can't operate with multiple "
"detached datafiles\n", me);
airMopError(mop);
return 1;
}
if (!( nrrdFormatNRRD == nio->format )) {
fprintf(stderr, "%s: can only print data of NRRD format files\n", me);
airMopError(mop); return 1;
}
car = fgetc(nio->dataFile);
#ifdef _MSC_VER
/* needed because otherwise printing a carraige return will
automatically also produce a newline */
_setmode(_fileno(stdout), _O_BINARY);
#endif
while (EOF != car) {
fputc(car, stdout);
car = fgetc(nio->dataFile);
}
airFclose(nio->dataFile);
airMopOkay(mop);
return 0;
}
int
_nrrdDataFNCheck(NrrdIoState *nio, Nrrd *nrrd, int useBiff) {
char me[]="_nrrdDataFNCheck", err[BIFF_STRLEN];
size_t pieceSize, pieceNum;
if (nio->dataFileDim < nrrd->dim) {
_nrrdSplitSizes(&pieceSize, &pieceNum, nrrd, nio->dataFileDim);
if (pieceNum != _nrrdDataFNNumber(nio)) {
sprintf(err, "%s: expected %d filenames (of %d-D pieces) but got %d",
me, (int)pieceNum, nio->dataFileDim,
(int)_nrrdDataFNNumber(nio));
biffMaybeAdd(NRRD, err, useBiff); return 1;
}
} else {
/* we're getting data in "slabs" with the same dimension as the
nrrd, so for simplicity we assume that they're all equal size */
if (_nrrdDataFNNumber(nio) > nrrd->axis[nrrd->dim-1].size) {
sprintf(err, "%s: can't have more pieces (%d) than axis %d "
"slices (" _AIR_SIZE_T_CNV ") when nrrd dimension and "
"datafile dimension are both %d", me,
(int)_nrrdDataFNNumber(nio),
nrrd->dim-1, nrrd->axis[nrrd->dim-1].size,
nrrd->dim);
biffMaybeAdd(NRRD, err, useBiff); return 1;
}
if ((double)nrrd->axis[nrrd->dim-1].size/_nrrdDataFNNumber(nio)
!= nrrd->axis[nrrd->dim-1].size/_nrrdDataFNNumber(nio)) {
sprintf(err, "%s: number of datafiles (%d) doesn't divide into "
"number of axis %d slices (" _AIR_SIZE_T_CNV ")", me,
(int)_nrrdDataFNNumber(nio),
nrrd->dim-1, nrrd->axis[nrrd->dim-1].size);
biffMaybeAdd(NRRD, err, useBiff); return 1;
}
}
return 0;
}
/*
** this is responsible for the header-relative path processing
**
** NOTE: if the filename is "-", then because it does not start with '/',
** it would normally be prefixed by nio->path, so it needs special handling
**
** NOTE: this should work okay with nio->headerStringRead, I think ...
*/
int
nrrdIoStateDataFileIterNext(FILE **fileP, NrrdIoState *nio, int reading) {
char me[]="nrrdIoStateDataFileIterNext", *err;
char *fname=NULL;
int ii, needPath;
unsigned int num, fi;
size_t maxl;
airArray *mop;
mop = airMopNew();
airMopAdd(mop, (void*)fileP, (airMopper)airSetNull, airMopOnError);
if (!fileP) {
if ((err = (char*)malloc(BIFF_STRLEN))) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(NRRD, err); free(err);
}
airMopError(mop); return 1;
}
if (!_nrrdDataFNNumber(nio)) {
if ((err = (char*)malloc(BIFF_STRLEN))) {
sprintf(err, "%s: there appear to be zero datafiles!", me);
biffAdd(NRRD, err); free(err);
}
airMopError(mop); return 1;
}
nio->dataFNIndex++;
if (nio->dataFNIndex >= (int)_nrrdDataFNNumber(nio)) {
/* there is no next data file, but we don't make that an error */
nio->dataFNIndex = _nrrdDataFNNumber(nio);
airMopOkay(mop);
*fileP = NULL;
return 0;
}
/* HEY: some of this error checking is done far more often than needed */
if (nio->dataFNFormat || nio->dataFNArr->len) {
needPath = AIR_FALSE;
maxl = 0;
if (nio->dataFNFormat) {
needPath = _NEED_PATH(nio->dataFNFormat);
/* assuming 10-digit integers is plenty big */
maxl = 10 + strlen(nio->dataFNFormat);
} else {
for (fi=0; fi<nio->dataFNArr->len; fi++) {
needPath |= _NEED_PATH(nio->dataFN[fi]);
maxl = AIR_MAX(maxl, strlen(nio->dataFN[fi]));
}
}
if (needPath && !airStrlen(nio->path)) {
if ((err = (char*)malloc(BIFF_STRLEN))) {
sprintf(err, "%s: need nio->path for header-relative datafiles", me);
biffAdd(NRRD, err); free(err);
}
airMopError(mop); return 1;
}
fname = (char*)malloc(airStrlen(nio->path) + strlen("/") + maxl + 1);
if (!fname) {
if ((err = (char*)malloc(BIFF_STRLEN))) {
sprintf(err, "%s: couldn't allocate filename buffer", me);
biffAdd(NRRD, err); free(err);
}
airMopError(mop); return 1;
}
airMopAdd(mop, fname, airFree, airMopAlways);
}
if (nio->dataFNFormat) {
/* ---------------------------------------------------------- */
/* --------- base.%d <min> <max> <step> [<dim>] ------------- */
/* ---------------------------------------------------------- */
num = 0;
for (ii = nio->dataFNMin;
((nio->dataFNStep > 0 && ii <= nio->dataFNMax)
|| (nio->dataFNStep < 0 && ii >= nio->dataFNMax));
ii += nio->dataFNStep) {
if ((int)num == nio->dataFNIndex) { /* HEY scrutinize cast */
break;
}
num += 1;
}
if (_NEED_PATH(nio->dataFNFormat)) {
strcpy(fname, nio->path);
strcat(fname, "/");
sprintf(fname + strlen(nio->path) + strlen("/"), nio->dataFNFormat, ii);
} else {
sprintf(fname, nio->dataFNFormat, ii);
}
} else if (nio->dataFNArr->len) {
/* ---------------------------------------------------------- */
/* ------------------- LIST or single ----------------------- */
/* ---------------------------------------------------------- */
if (_NEED_PATH(nio->dataFN[nio->dataFNIndex])) {
sprintf(fname, "%s/%s", nio->path, nio->dataFN[nio->dataFNIndex]);
} else {
strcpy(fname, nio->dataFN[nio->dataFNIndex]);
}
}
/* else data file is attached */
if (nio->dataFNFormat || nio->dataFNArr->len) {
*fileP = airFopen(fname, reading ? stdin : stdout, reading ? "rb" : "wb");
if (!(*fileP)) {
if ((err = (char*)malloc(strlen(fname) + BIFF_STRLEN))) {
sprintf(err, "%s: couldn't open \"%s\" (data file %d of %d) for %s",
me, fname, nio->dataFNIndex+1, (int)_nrrdDataFNNumber(nio),
reading ? "reading" : "writing");
biffAdd(NRRD, err); free(err);
}
airMopError(mop); return 1;
}
} else {
/* data file is attached */
if (nio->headerStringRead) {
/* except we were never reading from a file to begin with, but this
isn't an error */
*fileP = NULL;
} else {
*fileP = nio->headerFile;
}
}
airMopOkay(mop);
return 0;
}
