/*
******** nrrdCheck()
**
** does some consistency checks for things that can go wrong in a nrrd
** returns non-zero if there is a problem, zero if no problem.
**
** You might think that this should be merged with _nrrdHeaderCheck(),
** but that is really only for testing sufficiency of information
** required to do the data reading.
*/
int /*Teem: biff if (ret) */
nrrdCheck(const Nrrd *nrrd) {
static const char me[]="nrrdCheck";
if (_nrrdCheck(nrrd, AIR_TRUE, AIR_TRUE)) {
biffAddf(NRRD, "%s: trouble", me);
return 1;
}
return 0;
}
/*
******** nrrdCheck()
**
** does some consistency checks for things that can go wrong in a nrrd
** returns non-zero if there is a problem, zero if no problem.
**
** You might think that this should be merged with _nrrdHeaderCheck(),
** but that is really only for testing sufficiency of information
** required to do the data reading.
*/
int
nrrdCheck(const Nrrd *nrrd) {
char me[]="nrrdCheck", err[BIFF_STRLEN];
if (_nrrdCheck(nrrd, AIR_TRUE, AIR_TRUE)) {
sprintf(err, "%s: trouble", me);
biffAdd(NRRD, err); return 1;
}
return 0;
}
/*
******** nrrdSpacingCalculate
**
** Determine nrrdSpacingStatus, and whatever can be calculated about
** spacing for a given axis. Takes a nrrd, an axis, a double pointer
** (for returning a scalar), a space vector, and an int pointer for
** returning the known length of the space vector.
**
** The behavior of what has been set by the function is determined by
** the return value, which takes values from the nrrdSpacingStatus*
** enum, as follows:
**
** returned status value: what it means, and what it set
** ---------------------------------------------------------------------------
** nrrdSpacingStatusUnknown Something about the given arguments is
** invalid.
** *spacing = NaN,
** vector = all NaNs
**
** nrrdSpacingStatusNone There is no spacing info at all:
** *spacing = NaN,
** vector = all NaNs
**
** nrrdSpacingStatusScalarNoSpace There is no surrounding space, but the
** axis's spacing was known.
** *spacing = axis->spacing,
** vector = all NaNs
**
** nrrdSpacingStatusScalarWithSpace There *is* a surrounding space, but the
** given axis does not live in that space,
** because it has no space direction. Caller
** may want to think about what's going on.
** *spacing = axis->spacing,
** vector = all NaNs
**
** nrrdSpacingStatusDirection There is a surrounding space, in which
** this axis has a direction V:
** *spacing = |V| (length of direction),
** vector = V/|V| (normalized direction)
** NOTE: it is still possible for both
** *spacing and vector to be all NaNs!!
*/
int
nrrdSpacingCalculate(const Nrrd *nrrd, unsigned int ax,
double *spacing, double vector[NRRD_SPACE_DIM_MAX]) {
int ret;
if (!( nrrd && spacing && vector
&& ax <= nrrd->dim-1
&& !_nrrdCheck(nrrd, AIR_FALSE, AIR_FALSE) )) {
/* there's a problem with the arguments. Note: the _nrrdCheck()
call does not check on non-NULL-ity of nrrd->data */
ret = nrrdSpacingStatusUnknown;
if (spacing) {
*spacing = AIR_NAN;
}
if (vector) {
nrrdSpaceVecSetNaN(vector);
}
} else {
if (AIR_EXISTS(nrrd->axis[ax].spacing)) {
if (nrrd->spaceDim > 0) {
ret = nrrdSpacingStatusScalarWithSpace;
} else {
ret = nrrdSpacingStatusScalarNoSpace;
}
*spacing = nrrd->axis[ax].spacing;
nrrdSpaceVecSetNaN(vector);
} else {
if (nrrd->spaceDim > 0 && _nrrdSpaceVecExists(nrrd, ax)) {
ret = nrrdSpacingStatusDirection;
*spacing = nrrdSpaceVecNorm(nrrd->spaceDim,
nrrd->axis[ax].spaceDirection);
nrrdSpaceVecScale(vector, 1.0/(*spacing),
nrrd->axis[ax].spaceDirection);
} else {
ret = nrrdSpacingStatusNone;
*spacing = AIR_NAN;
nrrdSpaceVecSetNaN(vector);
}
}
}
return ret;
}
