/*
******** nrrdSpaceDimension
**
** returns expected dimension of given space (from nrrdSpace* enum), or,
** 0 if there is no expected dimension.
**
** The expected behavior here is to return 0 for nrrdSpaceUnknown, because
** that is the right answer, not because its an error of any kind.
*/
unsigned int
nrrdSpaceDimension(int space) {
static const char me[]="nrrdSpaceDimension";
unsigned int ret;
if (!( AIR_IN_OP(nrrdSpaceUnknown, space, nrrdSpaceLast) )) {
/* they gave us invalid or unknown space */
return 0;
}
switch (space) {
case nrrdSpaceRightAnteriorSuperior:
case nrrdSpaceLeftAnteriorSuperior:
case nrrdSpaceLeftPosteriorSuperior:
case nrrdSpaceScannerXYZ:
case nrrdSpace3DRightHanded:
case nrrdSpace3DLeftHanded:
ret = 3;
break;
case nrrdSpaceRightAnteriorSuperiorTime:
case nrrdSpaceLeftAnteriorSuperiorTime:
case nrrdSpaceLeftPosteriorSuperiorTime:
case nrrdSpaceScannerXYZTime:
case nrrdSpace3DRightHandedTime:
case nrrdSpace3DLeftHandedTime:
ret = 4;
break;
default:
fprintf(stderr, "%s: PANIC: nrrdSpace %d not implemented!\n", me, space);
ret = UINT_MAX; /* exit(1); */
break;
}
return ret;
}
int
mossImageAlloc (Nrrd *image, int type, int sx, int sy, int ncol) {
static const char me[]="mossImageAlloc";
int ret;
if (!(image && AIR_IN_OP(nrrdTypeUnknown, type, nrrdTypeBlock)
&& sx > 0 && sy > 0 && ncol > 0)) {
biffAddf(MOSS, "%s: got NULL pointer or bad args", me);
return 1;
}
if (1 == ncol) {
ret = nrrdMaybeAlloc_va(image, type, 2,
AIR_CAST(size_t, sx),
AIR_CAST(size_t, sy));
} else {
ret = nrrdMaybeAlloc_va(image, type, 3,
AIR_CAST(size_t, ncol),
AIR_CAST(size_t, sx),
AIR_CAST(size_t, sy));
}
if (ret) {
biffMovef(MOSS, NRRD, "%s: couldn't allocate image", me);
return 1;
}
return 0;
}
int
mossImageAlloc (Nrrd *image, int type, int sx, int sy, int ncol) {
char me[]="mossImageAlloc", err[BIFF_STRLEN];
int ret;
if (!(image && AIR_IN_OP(nrrdTypeUnknown, type, nrrdTypeBlock)
&& sx > 0 && sy > 0 && ncol > 0)) {
sprintf(err, "%s: got NULL pointer or bad args", me);
biffAdd(MOSS, err);
return 1;
}
if (1 == ncol) {
ret = nrrdMaybeAlloc_va(image, type, 2,
AIR_CAST(size_t, sx),
AIR_CAST(size_t, sy));
} else {
ret = nrrdMaybeAlloc_va(image, type, 3,
AIR_CAST(size_t, ncol),
AIR_CAST(size_t, sx),
AIR_CAST(size_t, sy));
}
if (ret) {
sprintf(err, "%s: couldn't allocate image", me);
biffMove(MOSS, err, NRRD);
return 1;
}
return 0;
}
int
_pullInitParmCheck(pullInitParm *iparm) {
static const char me[]="_pullInitParmCheck";
if (!AIR_IN_OP(pullInitMethodUnknown, iparm->method, pullInitMethodLast)) {
biffAddf(PULL, "%s: init method %d not valid", me, iparm->method);
return 1;
}
CHECK(jitter, 0.0, 2.0);
switch (iparm->method) {
case pullInitMethodGivenPos:
if (nrrdCheck(iparm->npos)) {
biffMovef(PULL, NRRD, "%s: got a broken npos", me);
return 1;
}
if (!( 2 == iparm->npos->dim
&& 4 == iparm->npos->axis[0].size
&& (nrrdTypeDouble == iparm->npos->type
|| nrrdTypeFloat == iparm->npos->type) )) {
biffAddf(PULL, "%s: npos not a 2-D 4-by-N array of %s or %s"
"(got %u-D %u-by-X of %s)", me,
airEnumStr(nrrdType, nrrdTypeFloat),
airEnumStr(nrrdType, nrrdTypeDouble),
iparm->npos->dim,
AIR_CAST(unsigned int, iparm->npos->axis[0].size),
airEnumStr(nrrdType, iparm->npos->type));
return 1;
}
break;
case pullInitMethodPointPerVoxel:
if (iparm->pointPerVoxel < -3001 || iparm->pointPerVoxel > 10) {
biffAddf(PULL, "%s: pointPerVoxel %d unreasonable", me,
iparm->pointPerVoxel);
return 1;
}
if (-1 == iparm->pointPerVoxel) {
biffAddf(PULL, "%s: pointPerVoxel should be < -1 or >= 1", me);
return 1;
}
if (0 == iparm->jitter && 1 < iparm->pointPerVoxel) {
biffAddf(PULL, "%s: must have jitter > 0 if pointPerVoxel (%d) > 1", me,
iparm->pointPerVoxel);
return 1;
}
break;
case pullInitMethodRandom:
case pullInitMethodHalton:
if (!( iparm->numInitial >= 1 )) {
biffAddf(PULL, "%s: iparm->numInitial (%d) not >= 1\n", me,
iparm->numInitial);
return 1;
}
break;
/* no check needed on haltonStartIndex */
default:
biffAddf(PULL, "%s: init method %d valid but not handled?", me,
iparm->method);
return 1;
}
int
tenFiberUpdate(tenFiberContext *tfx) {
char me[]="tenFiberUpdate", err[BIFF_STRLEN];
if (!tfx) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(TEN, err); return 1;
}
if (tenFiberTypeUnknown == tfx->fiberType) {
sprintf(err, "%s: fiber type not set", me);
biffAdd(TEN, err); return 1;
}
if (!( AIR_IN_OP(tenFiberTypeUnknown, tfx->fiberType, tenFiberTypeLast) )) {
sprintf(err, "%s: tfx->fiberType set to bogus value (%d)", me,
tfx->fiberType);
biffAdd(TEN, err); return 1;
}
if (tenFiberIntgUnknown == tfx->intg) {
sprintf(err, "%s: integration type not set", me);
biffAdd(TEN, err); return 1;
}
if (!( AIR_IN_OP(tenFiberIntgUnknown, tfx->intg, tenFiberIntgLast) )) {
sprintf(err, "%s: tfx->intg set to bogus value (%d)", me, tfx->intg);
biffAdd(TEN, err); return 1;
}
if (0 == tfx->stop) {
sprintf(err, "%s: no fiber stopping criteria set", me);
biffAdd(TEN, err); return 1;
}
if (gageQuerySet(tfx->gtx, tfx->pvl, tfx->query)
|| gageUpdate(tfx->gtx)) {
sprintf(err, "%s: trouble with gage", me);
biffMove(TEN, err, GAGE); return 1;
}
if (tfx->useDwi) {
if (!(0 == tfx->ten2Which || 1 == tfx->ten2Which)) {
sprintf(err, "%s: ten2Which must be 0 or 1 (not %u)",
me, tfx->ten2Which);
biffAdd(TEN, err); return 1;
}
}
return 0;
}
/*
** no biff
*/
int
nrrdIoStateGet(NrrdIoState *nio, int parm)
{
char me[]="nrrdIoStateGet";
int value;
if (!nio)
{
/* got NULL pointer */
return -1;
}
if (!( AIR_IN_OP(nrrdIoStateUnknown, parm, nrrdIoStateLast) ))
{
/* got bogus parameter identifier */
return -1;
}
switch (parm)
{
case nrrdIoStateDetachedHeader:
value = !!nio->detachedHeader;
break;
case nrrdIoStateBareText:
value = !!nio->bareText;
break;
case nrrdIoStateCharsPerLine:
value = nio->charsPerLine;
break;
case nrrdIoStateValsPerLine:
value = nio->valsPerLine;
break;
case nrrdIoStateSkipData:
value = !!nio->skipData;
break;
case nrrdIoStateKeepNrrdDataFileOpen:
value = !!nio->keepNrrdDataFileOpen;
break;
case nrrdIoStateZlibLevel:
value = nio->zlibLevel;
break;
case nrrdIoStateZlibStrategy:
value = nio->zlibStrategy;
break;
case nrrdIoStateBzip2BlockSize:
value = nio->bzip2BlockSize;
break;
default:
fprintf(stderr, "!%s: PANIC: didn't recognize parm %d\n", me, parm);
exit(1);
}
return value;
}
/*
******** nrrdPad_va()
**
** strictly for padding
*/
int
nrrdPad_va(Nrrd *nout, const Nrrd *nin,
const ptrdiff_t *min, const ptrdiff_t *max, int boundary, ...) {
static const char me[]="nrrdPad_va", func[]="pad";
char buff1[NRRD_DIM_MAX*30], buff2[AIR_STRLEN_MED];
double padValue=AIR_NAN;
int outside; /* whether current sample in output has any coordinates
that are outside the input volume (this is per-sample,
not per-axis) */
unsigned int ai;
ptrdiff_t
cIn[NRRD_DIM_MAX]; /* coords for line start, in input */
size_t
typeSize,
idxIn, idxOut, /* linear indices for input and output */
numOut, /* number of elements in output nrrd */
szIn[NRRD_DIM_MAX],
szOut[NRRD_DIM_MAX],
cOut[NRRD_DIM_MAX]; /* coords for line start, in output */
va_list ap;
char *dataIn, *dataOut;
char stmp[2][AIR_STRLEN_SMALL];
if (!(nout && nin && min && max)) {
biffAddf(NRRD, "%s: got NULL pointer", me);
return 1;
}
if (nout == nin) {
biffAddf(NRRD, "%s: nout==nin disallowed", me);
return 1;
}
if (!AIR_IN_OP(nrrdBoundaryUnknown, boundary, nrrdBoundaryLast)) {
biffAddf(NRRD, "%s: boundary behavior %d invalid", me, boundary);
return 1;
}
if (nrrdBoundaryWeight == boundary) {
biffAddf(NRRD, "%s: boundary strategy %s not applicable here", me,
airEnumStr(nrrdBoundary, boundary));
return 1;
}
if (nrrdTypeBlock == nin->type && nrrdBoundaryPad == boundary) {
biffAddf(NRRD, "%s: with nrrd type %s, boundary %s not valid", me,
airEnumStr(nrrdType, nrrdTypeBlock),
airEnumStr(nrrdBoundary, nrrdBoundaryPad));
return 1;
}
va_start(ap, boundary);
if (nrrdBoundaryPad == boundary) {
padValue = va_arg(ap, double);
}
baneClip *
baneClipNew(int type, double *parm) {
static const char me[]="baneClipNew";
baneClip *clip;
if (!( AIR_IN_OP(baneClipUnknown, type, baneClipLast) )) {
biffAddf(BANE, "%s: baneClip %d invalid", me, type);
return NULL;
}
if (!parm) {
biffAddf(BANE, "%s: got NULL pointer", me);
return NULL;
}
if (!(AIR_EXISTS(parm[0]))) {
biffAddf(BANE, "%s: parm[0] doesn't exist", me);
return NULL;
}
clip = (baneClip*)calloc(1, sizeof(baneClip));
if (!clip) {
biffAddf(BANE, "%s: couldn't allocate baneClip!", me);
return NULL;
}
clip->parm[0] = parm[0];
clip->type = type;
switch(type) {
case baneClipAbsolute:
sprintf(clip->name, "absolute");
clip->answer = _baneClipAnswer_Absolute;
break;
case baneClipPeakRatio:
sprintf(clip->name, "peak ratio");
clip->answer = _baneClipAnswer_PeakRatio;
break;
case baneClipPercentile:
sprintf(clip->name, "percentile");
clip->answer = _baneClipAnswer_Percentile;
break;
case baneClipTopN:
sprintf(clip->name, "top N");
clip->answer = _baneClipAnswer_TopN;
break;
default:
biffAddf(BANE, "%s: sorry, baneClip %d not implemented", me, type);
baneClipNix(clip); return NULL;
break;
}
return clip;
}
int
tenFiberIntgSet(tenFiberContext *tfx, int intg) {
char me[]="tenFiberIntTypeSet", err[BIFF_STRLEN];
if (!(tfx)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(TEN, err); return 1;
}
if (!( AIR_IN_OP(tenFiberIntgUnknown, intg, tenFiberIntgLast) )) {
sprintf(err, "%s: got invalid integration type %d", me, intg);
biffAdd(TEN, err); return 1;
}
tfx->intg = intg;
return 0;
}
baneRange *
baneRangeNew(int type) {
char me[]="baneRangeNew", err[BIFF_STRLEN];
baneRange *range = NULL;
if (!AIR_IN_OP(baneRangeUnknown, type, baneRangeLast)) {
sprintf(err, "%s: baneRange %d not valid", me, type);
biffAdd(BANE, err); return NULL;
}
range = (baneRange *)calloc(1, sizeof(baneRange));
if (!range) {
sprintf(err, "%s: couldn't allocate baneRange!", me);
biffAdd(BANE, err); return NULL;
}
range->type = type;
range->center = AIR_NAN;
switch(type) {
case baneRangePositive:
sprintf(range->name, "positive");
range->answer = _baneRangePositive_Answer;
break;
case baneRangeNegative:
sprintf(range->name, "negative");
range->answer = _baneRangeNegative_Answer;
break;
case baneRangeZeroCentered:
sprintf(range->name, "zero-centered");
range->answer = _baneRangeZeroCentered_Answer;
break;
case baneRangeAnywhere:
sprintf(range->name, "anywhere");
range->answer = _baneRangeAnywhere_Answer;
break;
default:
sprintf(err, "%s: Sorry, baneRange %d not implemented", me, type);
biffAdd(BANE, err); baneRangeNix(range); return NULL;
}
return range;
}
int
tenGlyphParmCheck(tenGlyphParm *parm,
const Nrrd *nten, const Nrrd *npos, const Nrrd *nslc) {
static const char me[]="tenGlyphParmCheck";
int duh;
size_t tenSize[3];
char stmp[5][AIR_STRLEN_SMALL];
if (!(parm && nten)) {
biffAddf(TEN, "%s: got NULL pointer", me);
return 1;
}
if (airEnumValCheck(tenAniso, parm->anisoType)) {
biffAddf(TEN, "%s: unset (or invalid) anisoType (%d)",
me, parm->anisoType);
return 1;
}
if (airEnumValCheck(tenAniso, parm->colAnisoType)) {
biffAddf(TEN, "%s: unset (or invalid) colAnisoType (%d)",
me, parm->colAnisoType);
return 1;
}
if (!( parm->facetRes >= 3 )) {
biffAddf(TEN, "%s: facet resolution %d not >= 3", me, parm->facetRes);
return 1;
}
if (!( AIR_IN_OP(tenGlyphTypeUnknown, parm->glyphType,
tenGlyphTypeLast) )) {
biffAddf(TEN, "%s: unset (or invalid) glyphType (%d)",
me, parm->glyphType);
return 1;
}
if (!( parm->glyphScale > 0)) {
biffAddf(TEN, "%s: glyphScale must be > 0 (not %g)", me, parm->glyphScale);
return 1;
}
if (parm->nmask) {
if (npos) {
biffAddf(TEN, "%s: can't do masking with explicit coordinate list", me);
return 1;
}
if (!( 3 == parm->nmask->dim
&& parm->nmask->axis[0].size == nten->axis[1].size
&& parm->nmask->axis[1].size == nten->axis[2].size
&& parm->nmask->axis[2].size == nten->axis[3].size )) {
biffAddf(TEN, "%s: mask isn't 3-D or doesn't have sizes (%s,%s,%s)", me,
airSprintSize_t(stmp[0], nten->axis[1].size),
airSprintSize_t(stmp[1], nten->axis[2].size),
airSprintSize_t(stmp[2], nten->axis[3].size));
return 1;
}
if (!(AIR_EXISTS(parm->maskThresh))) {
biffAddf(TEN, "%s: maskThresh hasn't been set", me);
return 1;
}
}
if (!( AIR_EXISTS(parm->anisoThresh)
&& AIR_EXISTS(parm->confThresh) )) {
biffAddf(TEN, "%s: anisoThresh and confThresh haven't both been set", me);
return 1;
}
if (parm->doSlice) {
if (npos) {
biffAddf(TEN, "%s: can't do slice with explicit coordinate list", me);
return 1;
}
if (!( parm->sliceAxis <=2 )) {
biffAddf(TEN, "%s: slice axis %d invalid", me, parm->sliceAxis);
return 1;
}
if (!( parm->slicePos < nten->axis[1+parm->sliceAxis].size )) {
biffAddf(TEN, "%s: slice pos %s not in valid range [0..%s]", me,
airSprintSize_t(stmp[0], parm->slicePos),
airSprintSize_t(stmp[1], nten->axis[1+parm->sliceAxis].size-1));
return 1;
}
if (nslc) {
if (2 != nslc->dim) {
biffAddf(TEN, "%s: explicit slice must be 2-D (not %d)",
me, nslc->dim);
return 1;
}
tenSize[0] = nten->axis[1].size;
tenSize[1] = nten->axis[2].size;
tenSize[2] = nten->axis[3].size;
for (duh=parm->sliceAxis; duh<2; duh++) {
tenSize[duh] = tenSize[duh+1];
}
if (!( tenSize[0] == nslc->axis[0].size
&& tenSize[1] == nslc->axis[1].size )) {
biffAddf(TEN, "%s: axis %u slice of %sx%sx%s volume != %sx%s", me,
parm->sliceAxis,
airSprintSize_t(stmp[0], nten->axis[1].size),
airSprintSize_t(stmp[1], nten->axis[2].size),
airSprintSize_t(stmp[2], nten->axis[3].size),
airSprintSize_t(stmp[3], nslc->axis[0].size),
airSprintSize_t(stmp[4], nslc->axis[1].size));
return 1;
}
} else {
if (airEnumValCheck(tenAniso, parm->sliceAnisoType)) {
biffAddf(TEN, "%s: unset (or invalid) sliceAnisoType (%d)",
me, parm->sliceAnisoType);
return 1;
}
}
}
return 0;
}
/*
** _nrrdSprintFieldInfo
**
** this prints "<prefix><field>: <info>" into *strP (after allocating it for
** big enough, usually with a stupidly big margin of error), in a form
** suitable to be written to NRRD or other image headers. This will always
** print something (for valid inputs), even stupid <info>s like
** "(unknown endian)". It is up to the caller to decide which fields
** are worth writing, via _nrrdFieldInteresting().
**
** NOTE: some of these fields make sense in non-NRRD files (e.g. all
** the per-axis information), but many only make sense in NRRD files.
** This is just one example of NRRD-format-specific stuff that is not
** in formatNRRD.c
*/
void
_nrrdSprintFieldInfo(char **strP, char *prefix,
const Nrrd *nrrd, NrrdIoState *nio, int field)
{
char me[]="_nrrdSprintFieldInfo", buff[AIR_STRLEN_MED], *fnb;
double colvec[NRRD_SPACE_DIM_MAX];
const char *fs;
unsigned int ii, dd,
uintStrlen = 11,
size_tStrlen = 33,
doubleStrlen = 513;
int fslen, fdlen, endi, maxl;
if (!( strP && prefix
&& nrrd
&& AIR_IN_CL(1, nrrd->dim, NRRD_DIM_MAX)
&& AIR_IN_OP(nrrdField_unknown, field, nrrdField_last) ))
{
return;
}
if (!_nrrdFieldInteresting(nrrd, nio, field))
{
*strP = airStrdup("");
}
fs = airEnumStr(nrrdField, field);
fslen = strlen(prefix) + strlen(fs) + strlen(": ") + 1;
switch (field)
{
case nrrdField_comment:
case nrrdField_keyvalue:
fprintf(stderr, "%s: CONFUSION: why are you calling me on \"%s\"?\n", me,
airEnumStr(nrrdField, nrrdField_comment));
*strP = airStrdup("");
break;
case nrrdField_content:
airOneLinify(nrrd->content);
*strP = (char *)calloc(fslen + strlen(nrrd->content), sizeof(char));
sprintf(*strP, "%s%s: %s", prefix, fs, nrrd->content);
break;
case nrrdField_number:
*strP = (char *)calloc(fslen + size_tStrlen, sizeof(char));
sprintf(*strP, "%s%s: " _AIR_SIZE_T_CNV, prefix, fs,
nrrdElementNumber(nrrd));
break;
case nrrdField_type:
*strP = (char *)calloc(fslen + strlen(airEnumStr(nrrdType, nrrd->type)),
sizeof(char));
sprintf(*strP, "%s%s: %s", prefix, fs, airEnumStr(nrrdType, nrrd->type));
break;
case nrrdField_block_size:
*strP = (char *)calloc(fslen + size_tStrlen, sizeof(char));
sprintf(*strP, "%s%s: " _AIR_SIZE_T_CNV, prefix, fs, nrrd->blockSize);
break;
case nrrdField_dimension:
*strP = (char *)calloc(fslen + uintStrlen, sizeof(char));
sprintf(*strP, "%s%s: %d", prefix, fs, nrrd->dim);
break;
case nrrdField_space:
*strP = (char *)calloc(fslen + strlen(airEnumStr(nrrdSpace, nrrd->space)),
sizeof(char));
sprintf(*strP, "%s%s: %s", prefix, fs, airEnumStr(nrrdSpace, nrrd->space));
break;
case nrrdField_space_dimension:
*strP = (char *)calloc(fslen + uintStrlen, sizeof(char));
sprintf(*strP, "%s%s: %d", prefix, fs, nrrd->spaceDim);
break;
/* ---- begin per-axis fields ---- */
case nrrdField_sizes:
*strP = (char *)calloc(fslen + nrrd->dim*(size_tStrlen + 1), sizeof(char));
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++)
{
sprintf(buff, " " _AIR_SIZE_T_CNV, nrrd->axis[ii].size);
strcat(*strP, buff);
}
break;
case nrrdField_spacings:
*strP = (char *)calloc(fslen + nrrd->dim*(doubleStrlen + 1), sizeof(char));
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++)
{
airSinglePrintf(NULL, buff, " %g", nrrd->axis[ii].spacing);
strcat(*strP, buff);
}
break;
case nrrdField_thicknesses:
*strP = (char *)calloc(fslen + nrrd->dim*(doubleStrlen + 1), sizeof(char));
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++)
{
airSinglePrintf(NULL, buff, " %g", nrrd->axis[ii].thickness);
strcat(*strP, buff);
}
break;
case nrrdField_axis_mins:
*strP = (char *)calloc(fslen + nrrd->dim*(doubleStrlen + 1), sizeof(char));
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++)
{
airSinglePrintf(NULL, buff, " %g", nrrd->axis[ii].min);
strcat(*strP, buff);
}
break;
case nrrdField_axis_maxs:
*strP = (char *)calloc(fslen + nrrd->dim*(doubleStrlen + 1), sizeof(char));
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++)
{
airSinglePrintf(NULL, buff, " %g", nrrd->axis[ii].max);
strcat(*strP, buff);
}
break;
case nrrdField_space_directions:
*strP = (char *)calloc(fslen +
nrrd->dim*nrrd->spaceDim*(doubleStrlen
+ strlen("(,) ")),
sizeof(char));
sprintf(*strP, "%s%s: ", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++)
{
_nrrdStrcatSpaceVector(*strP, nrrd->spaceDim,
nrrd->axis[ii].spaceDirection);
if (ii < nrrd->dim-1)
{
strcat(*strP, " ");
}
}
break;
case nrrdField_centers:
fdlen = 0;
for (ii=0; ii<nrrd->dim; ii++)
{
fdlen += 1 + airStrlen(nrrd->axis[ii].center
? airEnumStr(nrrdCenter, nrrd->axis[ii].center)
: NRRD_UNKNOWN);
}
*strP = (char *)calloc(fslen + fdlen, sizeof(char));
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++)
{
sprintf(buff, " %s",
(nrrd->axis[ii].center
? airEnumStr(nrrdCenter, nrrd->axis[ii].center)
: NRRD_UNKNOWN));
strcat(*strP, buff);
}
break;
case nrrdField_kinds:
fdlen = 0;
for (ii=0; ii<nrrd->dim; ii++)
{
fdlen += 1 + airStrlen(nrrd->axis[ii].kind
? airEnumStr(nrrdKind, nrrd->axis[ii].kind)
: NRRD_UNKNOWN);
}
*strP = (char *)calloc(fslen + fdlen, sizeof(char));
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++)
{
sprintf(buff, " %s",
(nrrd->axis[ii].kind
? airEnumStr(nrrdKind, nrrd->axis[ii].kind)
: NRRD_UNKNOWN));
strcat(*strP, buff);
}
break;
case nrrdField_labels:
fdlen = 0;
for (ii=0; ii<nrrd->dim; ii++)
{
fdlen += airStrlen(nrrd->axis[ii].label) + 4;
}
*strP = (char *)calloc(fslen + fdlen, sizeof(char));
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++)
{
strcat(*strP, " \"");
if (airStrlen(nrrd->axis[ii].label))
{
strcat(*strP, nrrd->axis[ii].label);
}
strcat(*strP, "\"");
}
break;
case nrrdField_units:
fdlen = 0;
for (ii=0; ii<nrrd->dim; ii++)
{
fdlen += airStrlen(nrrd->axis[ii].units) + 4;
}
*strP = (char *)calloc(fslen + fdlen, sizeof(char));
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++)
{
strcat(*strP, " \"");
if (airStrlen(nrrd->axis[ii].units))
{
strcat(*strP, nrrd->axis[ii].units);
}
strcat(*strP, "\"");
}
break;
/* ---- end per-axis fields ---- */
case nrrdField_min:
case nrrdField_max:
/* we're basically a no-op, now that these fields became meaningless */
*strP = (char *)calloc(fslen + doubleStrlen, sizeof(char));
sprintf(*strP, "%s%s: 0.0", prefix, fs);
strcat(*strP, buff);
break;
case nrrdField_old_min:
*strP = (char *)calloc(fslen + doubleStrlen, sizeof(char));
sprintf(*strP, "%s%s: ", prefix, fs);
airSinglePrintf(NULL, buff, "%g", nrrd->oldMin);
strcat(*strP, buff);
break;
case nrrdField_old_max:
*strP = (char *)calloc(fslen + doubleStrlen, sizeof(char));
sprintf(*strP, "%s%s: ", prefix, fs);
airSinglePrintf(NULL, buff, "%g", nrrd->oldMax);
strcat(*strP, buff);
break;
case nrrdField_endian:
if (airEndianUnknown != nio->endian)
{
/* we know a specific endianness because either it was recorded as
part of "unu make -h", or it was set (and data was possibly
altered) as part of "unu save" */
endi = nio->endian;
}
else
{
/* we record our current architecture's endian because we're
going to writing out data */
endi = AIR_ENDIAN;
}
*strP = (char *)calloc(fslen + strlen(airEnumStr(airEndian, endi)),
sizeof(char));
sprintf(*strP, "%s%s: %s", prefix, fs, airEnumStr(airEndian, endi));
break;
case nrrdField_encoding:
*strP = (char *)calloc(fslen + strlen(nio->encoding->name),
sizeof(char));
sprintf(*strP, "%s%s: %s", prefix, fs, nio->encoding->name);
break;
case nrrdField_line_skip:
*strP = (char *)calloc(fslen + uintStrlen, sizeof(char));
sprintf(*strP, "%s%s: %d", prefix, fs, nio->lineSkip);
break;
case nrrdField_byte_skip:
*strP = (char *)calloc(fslen + uintStrlen, sizeof(char));
sprintf(*strP, "%s%s: %d", prefix, fs, nio->byteSkip);
break;
case nrrdField_sample_units:
airOneLinify(nrrd->sampleUnits);
*strP = (char *)calloc(fslen + strlen(nrrd->sampleUnits), sizeof(char));
sprintf(*strP, "%s%s: \"%s\"", prefix, fs, nrrd->sampleUnits);
break;
case nrrdField_space_units:
fdlen = 0;
for (ii=0; ii<nrrd->spaceDim; ii++)
{
fdlen += airStrlen(nrrd->spaceUnits[ii]) + 4;
}
*strP = (char *)calloc(fslen + fdlen, sizeof(char));
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->spaceDim; ii++)
{
strcat(*strP, " \"");
if (airStrlen(nrrd->spaceUnits[ii]))
{
strcat(*strP, nrrd->spaceUnits[ii]);
}
strcat(*strP, "\"");
}
break;
case nrrdField_space_origin:
*strP = (char *)calloc(fslen + nrrd->spaceDim*(doubleStrlen
+ strlen("(,) ")),
sizeof(char));
sprintf(*strP, "%s%s: ", prefix, fs);
_nrrdStrcatSpaceVector(*strP, nrrd->spaceDim, nrrd->spaceOrigin);
break;
case nrrdField_measurement_frame:
*strP = (char *)calloc(fslen + (nrrd->spaceDim*
nrrd->spaceDim*(doubleStrlen
+ strlen("(,) "))),
sizeof(char));
sprintf(*strP, "%s%s: ", prefix, fs);
for (dd=0; dd<nrrd->spaceDim; dd++)
{
for (ii=0; ii<nrrd->spaceDim; ii++)
{
colvec[ii] = nrrd->measurementFrame[dd][ii];
}
_nrrdStrcatSpaceVector(*strP, nrrd->spaceDim, colvec);
if (dd < nrrd->spaceDim-1)
{
strcat(*strP, " ");
}
}
break;
case nrrdField_data_file:
/* NOTE: this comes last (nrrdField_data_file is the highest-valued
member of the nrrdField* enum) because the "LIST" form of the
data file specification requires that the following lines be
the filenames */
/* error checking elsewhere: assumes there is data file info */
if (nio->dataFNFormat)
{
*strP = (char *)calloc(fslen + strlen(nio->dataFNFormat) + 4*uintStrlen,
sizeof(char));
if (nio->dataFileDim == nrrd->dim-1)
{
sprintf(*strP, "%s%s: %s %d %d %d", prefix, fs, nio->dataFNFormat,
nio->dataFNMin, nio->dataFNMax, nio->dataFNStep);
}
else
{
sprintf(*strP, "%s%s: %s %d %d %d %d", prefix, fs, nio->dataFNFormat,
nio->dataFNMin, nio->dataFNMax, nio->dataFNStep,
nio->dataFileDim);
}
}
else if (nio->dataFNArr->len > 1)
{
maxl = 0;
for (ii=0; ii<nio->dataFNArr->len; ii++)
{
maxl = AIR_MAX(maxl, (int)strlen(nio->dataFN[ii]));
}
*strP = (char *)calloc(fslen + strlen(NRRD_LIST_FLAG)
+ uintStrlen + nio->dataFNArr->len * (maxl + 1),
sizeof(char));
fnb = (char *)calloc(fslen + strlen(NRRD_LIST_FLAG)
+ uintStrlen + maxl + 1,
sizeof(char));
if (nio->dataFileDim == nrrd->dim-1)
{
sprintf(*strP, "%s%s: LIST\n", prefix, fs);
}
else
{
sprintf(*strP, "%s%s: LIST %d\n", prefix, fs, nio->dataFileDim);
}
for (ii=0; ii<nio->dataFNArr->len; ii++)
{
sprintf(fnb, "%s%s", nio->dataFN[ii],
ii<nio->dataFNArr->len-1 ? "\n" : "");
strcat(*strP, fnb);
}
free(fnb);
}
else
{
/* there is some ambiguity between a "LIST" of length one,
and a single explicit data filename, but that's harmless */
*strP = (char *)calloc(fslen + strlen("./")
+ strlen(nio->dataFN[0]) + 1,
sizeof(char));
sprintf(*strP, "%s%s: %s%s", prefix, fs,
/* this is a favor to older readers that can deal with
this NRRD file because its being saved in a NRRD0003
(or below) version, so we don't want to confuse them
by not having the old explicit header-relative flag */
(_nrrdFormatNRRD_whichVersion(nrrd, nio) < 4 ? "./" : ""),
nio->dataFN[0]);
}
break;
default:
fprintf(stderr, "%s: CONFUSION: field %d unrecognized\n", me, field);
break;
}
return;
}
int
nrrdIoStateSet(NrrdIoState *nio, int parm, int value)
{
char me[]="nrrdIoStateSet", err[BIFF_STRLEN];
if (!nio)
{
sprintf(err, "%s: got NULL pointer", me);
biffAdd(NRRD, err);
return 1;
}
if (!( AIR_IN_OP(nrrdIoStateUnknown, parm, nrrdIoStateLast) ))
{
sprintf(err, "%s: identifier %d not in valid range [%d,%d]", me,
parm, nrrdIoStateUnknown+1, nrrdIoStateLast-1);
biffAdd(NRRD, err);
return 1;
}
switch (parm)
{
case nrrdIoStateDetachedHeader:
nio->detachedHeader = !!value;
break;
case nrrdIoStateBareText:
nio->bareText = !!value;
break;
case nrrdIoStateCharsPerLine:
if (value < 40)
{
sprintf(err, "%s: %d charsPerLine is awfully small", me, value);
biffAdd(NRRD, err);
return 1;
}
nio->charsPerLine = value;
break;
case nrrdIoStateValsPerLine:
if (value < 4)
{
sprintf(err, "%s: %d valsPerLine is awfully small", me, value);
biffAdd(NRRD, err);
return 1;
}
nio->valsPerLine = value;
break;
case nrrdIoStateSkipData:
nio->skipData = !!value;
break;
case nrrdIoStateKeepNrrdDataFileOpen:
nio->keepNrrdDataFileOpen = !!value;
break;
case nrrdIoStateZlibLevel:
if (!( AIR_IN_CL(-1, value, 9) ))
{
sprintf(err, "%s: zlibLevel %d invalid", me, value);
biffAdd(NRRD, err);
return 1;
}
nio->zlibLevel = value;
break;
case nrrdIoStateZlibStrategy:
if (!( AIR_IN_OP(nrrdZlibStrategyUnknown, value, nrrdZlibStrategyLast) ))
{
sprintf(err, "%s: zlibStrategy %d invalid", me, value);
biffAdd(NRRD, err);
return 1;
}
nio->zlibStrategy = value;
break;
case nrrdIoStateBzip2BlockSize:
if (!( AIR_IN_CL(-1, value, 9) ))
{
sprintf(err, "%s: bzip2BlockSize %d invalid", me, value);
biffAdd(NRRD, err);
return 1;
}
nio->bzip2BlockSize = value;
break;
default:
fprintf(stderr, "!%s: PANIC: didn't recognize parm %d\n", me, parm);
exit(1);
}
return 0;
}
int
_nrrdFieldInteresting(const Nrrd *nrrd, NrrdIoState *nio, int field)
{
int ret;
unsigned int ai;
if (!( nrrd
&& AIR_IN_CL(1, nrrd->dim, NRRD_DIM_MAX)
&& nio
&& nio->encoding
&& AIR_IN_OP(nrrdField_unknown, field, nrrdField_last) ))
{
return 0;
}
ret = 0;
switch (field)
{
case nrrdField_comment:
/* comments and key/value pairs are always handled differently (by
being printed explicity), so they are never "interesting" */
break;
case nrrdField_content:
ret = !!(airStrlen(nrrd->content));
break;
case nrrdField_number:
/* "number" is entirely redundant with "sizes", which is a
required field. Absolutely nothing is lost in eliding "number"
from the header, so "number" is NEVER interesting. Should this
judgement later be found in error, this is the one place where
the policy change can be implemented */
break;
case nrrdField_type:
/* this is vital */
ret = 1;
break;
case nrrdField_block_size:
ret = (nrrdTypeBlock == nrrd->type);
break;
case nrrdField_dimension:
/* this is vital */
ret = 1;
break;
case nrrdField_space:
/* its interesting if its known */
ret = (nrrdSpaceUnknown != nrrd->space);
break;
case nrrdField_space_dimension:
/* its interesting if its non-zero and if space is not known */
ret = (nrrd->spaceDim > 0 && nrrdSpaceUnknown == nrrd->space);
break;
case nrrdField_sizes:
/* this is vital */
ret = 1;
break;
case nrrdField_spacings:
for (ai=0; ai<nrrd->dim; ai++)
{
ret |= AIR_EXISTS(nrrd->axis[ai].spacing);
}
break;
case nrrdField_thicknesses:
for (ai=0; ai<nrrd->dim; ai++)
{
ret |= AIR_EXISTS(nrrd->axis[ai].thickness);
}
break;
case nrrdField_axis_mins:
for (ai=0; ai<nrrd->dim; ai++)
{
ret |= AIR_EXISTS(nrrd->axis[ai].min);
}
break;
case nrrdField_axis_maxs:
for (ai=0; ai<nrrd->dim; ai++)
{
ret |= AIR_EXISTS(nrrd->axis[ai].max);
}
break;
case nrrdField_space_directions:
ret = nrrd->spaceDim > 0;
break;
case nrrdField_centers:
for (ai=0; ai<nrrd->dim; ai++)
{
ret |= (nrrdCenterUnknown != nrrd->axis[ai].center);
}
break;
case nrrdField_kinds:
for (ai=0; ai<nrrd->dim; ai++)
{
ret |= (nrrdKindUnknown != nrrd->axis[ai].kind);
}
break;
case nrrdField_labels:
for (ai=0; ai<nrrd->dim; ai++)
{
ret |= !!(airStrlen(nrrd->axis[ai].label));
}
break;
case nrrdField_units:
for (ai=0; ai<nrrd->dim; ai++)
{
ret |= !!(airStrlen(nrrd->axis[ai].units));
}
break;
case nrrdField_min:
case nrrdField_max:
/* these no longer exist in the Nrrd struct; we never write them */
ret = AIR_FALSE;
break;
case nrrdField_old_min:
ret = AIR_EXISTS(nrrd->oldMin);
break;
case nrrdField_old_max:
ret = AIR_EXISTS(nrrd->oldMax);
break;
case nrrdField_endian:
ret = nio->encoding->endianMatters && 1 < nrrdElementSize(nrrd);
break;
case nrrdField_encoding:
/* this is vital */
ret = 1;
break;
case nrrdField_line_skip:
ret = nio->lineSkip > 0;
break;
case nrrdField_byte_skip:
ret = nio->byteSkip != 0;
break;
case nrrdField_keyvalue:
/* comments and key/value pairs are always handled differently (by
being printed explicity), so they are never "interesting" */
break;
case nrrdField_sample_units:
ret = airStrlen(nrrd->sampleUnits);
break;
case nrrdField_space_units:
for (ai=0; ai<nrrd->spaceDim; ai++)
{
ret |= !!(airStrlen(nrrd->spaceUnits[ai]));
}
break;
case nrrdField_space_origin:
/* we're trusting other validity checks to ensure that
all the coeffs exist or not, together */
ret = (nrrd->spaceDim > 0
&& AIR_EXISTS(nrrd->spaceOrigin[0]));
break;
case nrrdField_measurement_frame:
/* we're trusting other validity checks to ensure that
all the coeffs exist or not, together */
ret = (nrrd->spaceDim > 0
&& AIR_EXISTS(nrrd->measurementFrame[0][0]));
break;
case nrrdField_data_file:
/* detached header was either requested or is required */
ret = (nio->detachedHeader
|| nio->dataFNFormat
|| nio->dataFNArr->len > 1);
break;
}
return ret;
}
/*
******** limnCameraPathMake
**
** uses limnSplines to do camera paths based on key-frames
**
** output: cameras at all "numFrames" frames are set in the
** PRE-ALLOCATED array of output cameras, "cam".
**
** input:
** keycam: array of keyframe cameras
** time: times associated with the key frames
** ---> both of these arrays are length "numKeys" <---
** trackWhat: takes values from the limnCameraPathTrack* enum
** quatType: spline to control camera orientations. This is needed for
** tracking at or from, but not needed for limnCameraPathTrackBoth.
** This is the only limnSplineTypeSpec* argument that can be NULL.
** posType: spline to control whichever of from, at, and up are needed for
** the given style of tracking.
** distType: spline to control neer, faar, dist: positions of near clipping,
** far clipping, and image plane, as well as the
** distance between from and at (which is used if not doing
** limnCameraPathTrackBoth)
** viewType: spline to control fov (and aspect, if you're crazy)
**
** NOTE: The "atRelative", "orthographic", and "rightHanded" fields
** are copied from keycam[0] into all output cam[i], but you still need
** to correctly set them for all keycam[i] for limnCameraUpdate to work
** as expected. Also, for the sake of simplicity, this function only works
** with fov and aspect, instead of {u,v}Range, and hence both "fov" and
** "aspect" need to set in *all* the keycams, even if neither of them
** ever changes!
*/
int
limnCameraPathMake(limnCamera *cam, int numFrames,
limnCamera *keycam, double *time, int numKeys,
int trackWhat,
limnSplineTypeSpec *quatType,
limnSplineTypeSpec *posType,
limnSplineTypeSpec *distType,
limnSplineTypeSpec *viewType) {
static const char me[]="limnCameraPathMake";
char which[AIR_STRLEN_MED];
airArray *mop;
Nrrd *nquat, *nfrom, *natpt, *nupvc, *ndist, *nfova, *ntime, *nsample;
double fratVec[3], *quat, *from, *atpt, *upvc, *dist, *fova,
W2V[9], N[3], fratDist;
limnSpline *timeSpline, *quatSpline, *fromSpline, *atptSpline, *upvcSpline,
*distSpline, *fovaSpline;
limnSplineTypeSpec *timeType;
int ii, E;
if (!( cam && keycam && time && posType && distType && viewType )) {
biffAddf(LIMN, "%s: got NULL pointer", me);
return 1;
}
if (!( AIR_IN_OP(limnCameraPathTrackUnknown, trackWhat,
limnCameraPathTrackLast) )) {
biffAddf(LIMN, "%s: trackWhat %d not in valid range [%d,%d]", me,
trackWhat, limnCameraPathTrackUnknown+1,
limnCameraPathTrackLast-1);
return 1;
}
if (limnCameraPathTrackBoth != trackWhat && !quatType) {
biffAddf(LIMN, "%s: need the quaternion limnSplineTypeSpec if not "
"doing trackBoth", me);
return 1;
}
/* create and allocate nrrds. For the time being, we're allocating
more different nrrds, and filling their contents, than we need
to-- nquat is not needed if we're doing limnCameraPathTrackBoth,
for example. However, we do make an effort to only do the spline
evaluation on the things we actually need to know. */
mop = airMopNew();
airMopAdd(mop, nquat = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nfrom = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, natpt = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nupvc = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, ndist = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, nfova = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
airMopAdd(mop, ntime = nrrdNew(), (airMopper)nrrdNix, airMopAlways);
if (nrrdWrap_va(ntime, time, nrrdTypeDouble, 1,
AIR_CAST(size_t, numKeys))) {
biffMovef(LIMN, NRRD, "%s: trouble wrapping time values", me);
airMopError(mop); return 1;
}
airMopAdd(mop, nsample = nrrdNew(), (airMopper)nrrdNuke, airMopAlways);
timeType = limnSplineTypeSpecNew(limnSplineTypeTimeWarp);
airMopAdd(mop, timeType, (airMopper)limnSplineTypeSpecNix, airMopAlways);
if (nrrdMaybeAlloc_va(nquat, nrrdTypeDouble, 2,
AIR_CAST(size_t, 4), AIR_CAST(size_t, numKeys))
|| nrrdMaybeAlloc_va(nfrom, nrrdTypeDouble, 2,
AIR_CAST(size_t, 3), AIR_CAST(size_t, numKeys))
|| nrrdMaybeAlloc_va(natpt, nrrdTypeDouble, 2,
AIR_CAST(size_t, 3), AIR_CAST(size_t, numKeys))
|| nrrdMaybeAlloc_va(nupvc, nrrdTypeDouble, 2,
AIR_CAST(size_t, 3), AIR_CAST(size_t, numKeys))
|| nrrdMaybeAlloc_va(ndist, nrrdTypeDouble, 2,
AIR_CAST(size_t, 4), AIR_CAST(size_t, numKeys))
|| nrrdMaybeAlloc_va(nfova, nrrdTypeDouble, 2,
AIR_CAST(size_t, 2), AIR_CAST(size_t, numKeys))) {
biffMovef(LIMN, NRRD, "%s: couldn't allocate buffer nrrds", me);
airMopError(mop); return 1;
}
quat = (double*)(nquat->data);
from = (double*)(nfrom->data);
atpt = (double*)(natpt->data);
upvc = (double*)(nupvc->data);
dist = (double*)(ndist->data);
fova = (double*)(nfova->data);
/* check cameras, and put camera information into nrrds */
for (ii=0; ii<numKeys; ii++) {
if (limnCameraUpdate(keycam + ii)) {
biffAddf(LIMN, "%s: trouble with camera at keyframe %d\n", me, ii);
airMopError(mop); return 1;
}
if (!( AIR_EXISTS(keycam[ii].fov) && AIR_EXISTS(keycam[ii].aspect) )) {
biffAddf(LIMN, "%s: fov, aspect not both defined on keyframe %d",
me, ii);
airMopError(mop); return 1;
}
ell_4m_to_q_d(quat + 4*ii, keycam[ii].W2V);
if (ii) {
if (0 > ELL_4V_DOT(quat + 4*ii, quat + 4*(ii-1))) {
ELL_4V_SCALE(quat + 4*ii, -1, quat + 4*ii);
}
}
ELL_3V_COPY(from + 3*ii, keycam[ii].from);
ELL_3V_COPY(atpt + 3*ii, keycam[ii].at);
ELL_3V_COPY(upvc + 3*ii, keycam[ii].up);
ELL_3V_SUB(fratVec, keycam[ii].from, keycam[ii].at);
fratDist = ELL_3V_LEN(fratVec);
ELL_4V_SET(dist + 4*ii, fratDist,
keycam[ii].neer, keycam[ii].dist, keycam[ii].faar);
ELL_2V_SET(fova + 2*ii, keycam[ii].fov, keycam[ii].aspect);
}
/* create splines from nrrds */
if (!( (strcpy(which, "quaternion"), quatSpline =
limnSplineCleverNew(nquat, limnSplineInfoQuaternion, quatType))
&& (strcpy(which, "from point"), fromSpline =
limnSplineCleverNew(nfrom, limnSplineInfo3Vector, posType))
&& (strcpy(which, "at point"), atptSpline =
limnSplineCleverNew(natpt, limnSplineInfo3Vector, posType))
&& (strcpy(which, "up vector"), upvcSpline =
limnSplineCleverNew(nupvc, limnSplineInfo3Vector, posType))
&& (strcpy(which, "plane distances"), distSpline =
limnSplineCleverNew(ndist, limnSplineInfo4Vector, distType))
&& (strcpy(which, "field-of-view"), fovaSpline =
limnSplineCleverNew(nfova, limnSplineInfo2Vector, viewType))
&& (strcpy(which, "time warp"), timeSpline =
limnSplineCleverNew(ntime, limnSplineInfoScalar, timeType)) )) {
biffAddf(LIMN, "%s: trouble creating %s spline", me, which);
airMopError(mop); return 1;
}
airMopAdd(mop, quatSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, fromSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, atptSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, upvcSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, distSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, fovaSpline, (airMopper)limnSplineNix, airMopAlways);
airMopAdd(mop, timeSpline, (airMopper)limnSplineNix, airMopAlways);
/* evaluate splines */
E = AIR_FALSE;
if (!E) E |= limnSplineSample(nsample, timeSpline,
limnSplineMinT(timeSpline), numFrames,
limnSplineMaxT(timeSpline));
quat = NULL;
from = NULL;
atpt = NULL;
upvc = NULL;
switch(trackWhat) {
case limnCameraPathTrackAt:
if (!E) E |= limnSplineNrrdEvaluate(natpt, atptSpline, nsample);
if (!E) atpt = (double*)(natpt->data);
if (!E) E |= limnSplineNrrdEvaluate(nquat, quatSpline, nsample);
if (!E) quat = (double*)(nquat->data);
break;
case limnCameraPathTrackFrom:
if (!E) E |= limnSplineNrrdEvaluate(nfrom, fromSpline, nsample);
if (!E) from = (double*)(nfrom->data);
if (!E) E |= limnSplineNrrdEvaluate(nquat, quatSpline, nsample);
if (!E) quat = (double*)(nquat->data);
break;
case limnCameraPathTrackBoth:
if (!E) E |= limnSplineNrrdEvaluate(nfrom, fromSpline, nsample);
if (!E) from = (double*)(nfrom->data);
if (!E) E |= limnSplineNrrdEvaluate(natpt, atptSpline, nsample);
if (!E) atpt = (double*)(natpt->data);
if (!E) E |= limnSplineNrrdEvaluate(nupvc, upvcSpline, nsample);
if (!E) upvc = (double*)(nupvc->data);
break;
}
dist = NULL;
if (!E) E |= limnSplineNrrdEvaluate(ndist, distSpline, nsample);
if (!E) dist = (double*)(ndist->data);
fova = NULL;
if (!E) E |= limnSplineNrrdEvaluate(nfova, fovaSpline, nsample);
if (!E) fova = (double*)(nfova->data);
if (E) {
biffAddf(LIMN, "%s: trouble evaluating splines", me);
airMopError(mop); return 1;
}
/* copy information from nrrds back into cameras */
for (ii=0; ii<numFrames; ii++) {
cam[ii].atRelative = keycam[0].atRelative;
cam[ii].orthographic = keycam[0].orthographic;
cam[ii].rightHanded = keycam[0].rightHanded;
if (limnCameraPathTrackBoth == trackWhat) {
ELL_3V_COPY(cam[ii].from, from + 3*ii);
ELL_3V_COPY(cam[ii].at, atpt + 3*ii);
ELL_3V_COPY(cam[ii].up, upvc + 3*ii);
} else {
fratDist = (dist + 4*ii)[0];
ell_q_to_3m_d(W2V, quat + 4*ii);
ELL_3MV_ROW1_GET(cam[ii].up, W2V);
if (cam[ii].rightHanded) {
ELL_3V_SCALE(cam[ii].up, -1, cam[ii].up);
}
ELL_3MV_ROW2_GET(N, W2V);
if (limnCameraPathTrackFrom == trackWhat) {
ELL_3V_COPY(cam[ii].from, from + 3*ii);
ELL_3V_SCALE_ADD2(cam[ii].at, 1.0, cam[ii].from, fratDist, N);
} else {
ELL_3V_COPY(cam[ii].at, atpt + 3*ii);
ELL_3V_SCALE_ADD2(cam[ii].from, 1.0, cam[ii].at, -fratDist, N);
}
}
cam[ii].neer = (dist + 4*ii)[1];
cam[ii].dist = (dist + 4*ii)[2];
cam[ii].faar = (dist + 4*ii)[3];
cam[ii].fov = (fova + 2*ii)[0];
cam[ii].aspect = (fova + 2*ii)[1];
if (limnCameraUpdate(cam + ii)) {
biffAddf(LIMN, "%s: trouble with output camera %d\n", me, ii);
airMopError(mop); return 1;
}
}
airMopOkay(mop);
return 0;
}
int
pullRun(pullContext *pctx) {
char me[]="pullRun", err[BIFF_STRLEN],
poutS[AIR_STRLEN_MED];
Nrrd *npos;
double time0, time1, enrLast,
enrNew=AIR_NAN, enrImprov=AIR_NAN, enrImprovAvg=AIR_NAN;
int converged;
unsigned firstIter;
if (pctx->verbose) {
fprintf(stderr, "%s: hello\n", me);
}
time0 = airTime();
firstIter = pctx->iter;
if (_pullIterate(pctx)) {
sprintf(err, "%s: trouble on priming iter %u", me, pctx->iter);
biffAdd(PULL, err); return 1;
}
pctx->iter += 1;
enrLast = enrNew = _pullEnergyTotal(pctx);
fprintf(stderr, "!%s: starting system energy = %g\n", me, enrLast);
enrImprov = enrImprovAvg = 0;
converged = AIR_FALSE;
while (pctx->iter < pctx->iterMax && !converged) {
if (pctx->snap && !(pctx->iter % pctx->snap)) {
npos = nrrdNew();
sprintf(poutS, "snap.%06d.pos.nrrd", pctx->iter);
if (pullOutputGet(npos, NULL, pctx)) {
sprintf(err, "%s: couldn't get snapshot for iter %d", me, pctx->iter);
biffAdd(PULL, err); return 1;
}
if (nrrdSave(poutS, npos, NULL)) {
sprintf(err, "%s: couldn't save snapshot for iter %d", me, pctx->iter);
biffMove(PULL, err, NRRD); return 1;
}
npos = nrrdNuke(npos);
}
if (_pullIterate(pctx)) {
sprintf(err, "%s: trouble on iter %d", me, pctx->iter);
biffAdd(PULL, err); return 1;
}
pctx->iter += 1;
enrNew = _pullEnergyTotal(pctx);
enrImprov = _PULL_IMPROV(enrLast, enrNew);
if (firstIter + 1 == pctx->iter) {
/* we need some way of artificially boosting enrImprovAvg when
we're just starting, so that we thwart the convergence test,
which we do because we don't have the history of iterations
that enrImprovAvg is supposed to describe. Using some scaling
of enrImprov is one possible hack. */
enrImprovAvg = 3*enrImprov;
} else {
enrImprovAvg = (2*enrImprovAvg + enrImprov)/3;
}
if (pctx->verbose > 1) {
fprintf(stderr, "%s: iter %u: e=%g,%g, de=%g,%g, s=%g,%g\n",
me, pctx->iter, enrLast, enrNew, enrImprov, enrImprovAvg,
_pullStepInterAverage(pctx), _pullStepConstrAverage(pctx));
}
enrLast = enrNew;
converged = AIR_IN_OP(0, enrImprovAvg, pctx->energyImprovMin);
if (converged && pctx->verbose) {
fprintf(stderr, "%s: %g < %g: converged!!\n", me,
enrImprovAvg, pctx->energyImprovMin);
}
_pullPointStepEnergyScale(pctx, pctx->opporStepScale);
}
fprintf(stderr, "%s: done (%d,%d) @ iter %u enr = %g enrImprov = %g,%g "
"stuck %u\n",
me, !(pctx->iter < pctx->iterMax), converged,
pctx->iter, enrNew, enrImprov, enrImprovAvg, pctx->stuckNum);
time1 = airTime();
pctx->timeRun += time1 - time0;
pctx->energy = enrNew;
return 0;
}
int
limnEnvMapFill(Nrrd *map, limnEnvMapCB cb, int qnMethod, void *data) {
char me[]="limnEnvMapFill", err[128];
int sx, sy;
int qn;
float vec[3], *mapData;
if (!(map && cb)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(LIMN, err); return 1;
}
if (!AIR_IN_OP(limnQNUnknown, qnMethod, limnQNLast)) {
sprintf(err, "%s: QN method %d invalid", me, qnMethod);
biffAdd(LIMN, err); return 1;
}
switch(qnMethod) {
case limnQN16checker:
case limnQN16octa:
sx = sy = 256;
break;
case limnQN14checker:
case limnQN14octa:
sx = sy = 128;
break;
case limnQN12checker:
case limnQN12octa:
sx = sy = 64;
break;
case limnQN10checker:
case limnQN10octa:
sx = sy = 32;
break;
case limnQN8checker:
case limnQN8octa:
sx = sy = 16;
break;
case limnQN15octa:
sx = 128;
sy = 256;
break;
case limnQN13octa:
sx = 64;
sy = 128;
break;
case limnQN11octa:
sx = 32;
sy = 64;
break;
case limnQN9octa:
sx = 16;
sy = 32;
break;
default:
sprintf(err, "%s: sorry, QN method %d not implemented", me, qnMethod);
biffAdd(LIMN, err); return 1;
}
if (nrrdMaybeAlloc_va(map, nrrdTypeFloat, 3,
AIR_CAST(size_t, 3),
AIR_CAST(size_t, sx),
AIR_CAST(size_t, sy))) {
sprintf(err, "%s: couldn't alloc output", me);
biffMove(LIMN, err, NRRD); return 1;
}
mapData = (float *)map->data;
for (qn=0; qn<sx*sy; qn++) {
limnQNtoV_f[qnMethod](vec, qn);
cb(mapData + 3*qn, vec, data);
}
return 0;
}
/*
******** nrrdAxisInfoSet_va()
**
** var args front-end for nrrdAxisInfoSet_nva
**
** types to pass, one for each dimension:
** nrrdAxisInfoSize: size_t
** nrrdAxisInfoSpacing: double
** nrrdAxisInfoThickness: double
** nrrdAxisInfoMin: double
** nrrdAxisInfoMax: double
** nrrdAxisInfoSpaceDirection: double*
** nrrdAxisInfoCenter: int
** nrrdAxisInfoKind: int
** nrrdAxisInfoLabel: char*
** nrrdAxisInfoUnits: char*
*/
void
nrrdAxisInfoSet_va(Nrrd *nrrd, int axInfo, ...) {
NRRD_TYPE_BIGGEST *buffer[NRRD_DIM_MAX];
_nrrdAxisInfoSetPtrs info;
unsigned int ai, si;
va_list ap;
double *dp, svec[NRRD_DIM_MAX][NRRD_SPACE_DIM_MAX];
if (!( nrrd
&& AIR_IN_CL(1, nrrd->dim, NRRD_DIM_MAX)
&& AIR_IN_OP(nrrdAxisInfoUnknown, axInfo, nrrdAxisInfoLast) )) {
return;
}
info.P = buffer;
va_start(ap, axInfo);
for (ai=0; ai<nrrd->dim; ai++) {
switch (axInfo) {
case nrrdAxisInfoSize:
info.ST[ai] = va_arg(ap, size_t);
/*
printf("!%s: got int[%d] = %d\n", "nrrdAxisInfoSet", d, info.I[ai]);
*/
break;
case nrrdAxisInfoSpaceDirection:
dp = va_arg(ap, double*); /* punting on using info enum */
/*
printf("!%s: got dp = %lu\n", "nrrdAxisInfoSet",
(unsigned long)(dp));
*/
for (si=0; si<nrrd->spaceDim; si++) {
/* nrrd->axis[ai].spaceDirection[si] = dp[si]; */
svec[ai][si] = dp[si];
}
for (si=nrrd->spaceDim; si<NRRD_SPACE_DIM_MAX; si++) {
/* nrrd->axis[ai].spaceDirection[si] = AIR_NAN; */
svec[ai][si] = dp[si];
}
break;
case nrrdAxisInfoCenter:
case nrrdAxisInfoKind:
info.I[ai] = va_arg(ap, int);
/*
printf("!%s: got int[%d] = %d\n",
"nrrdAxisInfoSet", d, info.I[ai]);
*/
break;
case nrrdAxisInfoSpacing:
case nrrdAxisInfoThickness:
case nrrdAxisInfoMin:
case nrrdAxisInfoMax:
info.D[ai] = va_arg(ap, double);
/*
printf("!%s: got double[%d] = %g\n",
"nrrdAxisInfoSet", d, info.D[ai]);
*/
break;
case nrrdAxisInfoLabel:
/* we DO NOT do the airStrdup() here because this pointer value is
just going to be handed to nrrdAxisInfoSet_nva(), which WILL do the
airStrdup(); we're not violating the rules for axis labels */
info.CP[ai] = va_arg(ap, char *);
/*
printf("!%s: got char*[%d] = |%s|\n",
"nrrdAxisInfoSet", d, info.CP[ai]);
*/
break;
case nrrdAxisInfoUnits:
/* see not above */
info.CP[ai] = va_arg(ap, char *);
break;
}
}
va_end(ap);
if (nrrdAxisInfoSpaceDirection != axInfo) {
/* now set the quantities which we've gotten from the var args */
nrrdAxisInfoSet_nva(nrrd, axInfo, info.P);
} else {
nrrdAxisInfoSet_nva(nrrd, axInfo, svec);
}
return;
}
/*
** types to pass, one for each dimension:
** nrrdAxisInfoSize: size_t*
** nrrdAxisInfoSpacing: double*
** nrrdAxisInfoThickness: double*
** nrrdAxisInfoMin: double*
** nrrdAxisInfoMax: double*
** nrrdAxisInfoSpaceDirection: double*
** nrrdAxisInfoCenter: int*
** nrrdAxisInfoKind: int*
** nrrdAxisInfoLabel: char**
** nrrdAxisInfoUnits: char**
*/
void
nrrdAxisInfoGet_va(const Nrrd *nrrd, int axInfo, ...) {
void *buffer[NRRD_DIM_MAX], *ptr;
_nrrdAxisInfoGetPtrs info;
unsigned int ai, si;
va_list ap;
double svec[NRRD_DIM_MAX][NRRD_SPACE_DIM_MAX];
if (!( nrrd
&& AIR_IN_CL(1, nrrd->dim, NRRD_DIM_MAX)
&& AIR_IN_OP(nrrdAxisInfoUnknown, axInfo, nrrdAxisInfoLast) )) {
return;
}
if (nrrdAxisInfoSpaceDirection != axInfo) {
info.P = buffer;
nrrdAxisInfoGet_nva(nrrd, axInfo, info.P);
} else {
nrrdAxisInfoGet_nva(nrrd, axInfo, svec);
}
va_start(ap, axInfo);
for (ai=0; ai<nrrd->dim; ai++) {
ptr = va_arg(ap, void*);
/*
printf("!%s(%d): ptr = %lu\n",
"nrrdAxisInfoGet", d, (unsigned long)ptr);
*/
switch (axInfo) {
case nrrdAxisInfoSize:
*((size_t*)ptr) = info.ST[ai];
break;
case nrrdAxisInfoSpacing:
case nrrdAxisInfoThickness:
case nrrdAxisInfoMin:
case nrrdAxisInfoMax:
*((double*)ptr) = info.D[ai];
/* printf("!%s: got double[%d] = %lg\n", "nrrdAxisInfoGet", d,
*((double*)ptr)); */
break;
case nrrdAxisInfoSpaceDirection:
for (si=0; si<nrrd->spaceDim; si++) {
((double*)ptr)[si] = svec[ai][si];
}
for (si=nrrd->spaceDim; si<NRRD_SPACE_DIM_MAX; si++) {
((double*)ptr)[si] = AIR_NAN;
}
break;
case nrrdAxisInfoCenter:
case nrrdAxisInfoKind:
*((int*)ptr) = info.I[ai];
/* printf("!%s: got int[%d] = %d\n",
"nrrdAxisInfoGet", d, *((int*)ptr)); */
break;
case nrrdAxisInfoLabel:
case nrrdAxisInfoUnits:
/* we DO NOT do the airStrdup() here because this pointer value just
came from nrrdAxisInfoGet_nva(), which already did the airStrdup() */
*((char**)ptr) = info.CP[ai];
/* printf("!%s: got char*[%d] = |%s|\n", "nrrdAxisInfoSet", d,
*((char**)ptr)); */
break;
}
}
va_end(ap);
return;
}
/*
******** tenFiberStopSet
**
** how to set stop criteria and their parameters. a little tricky because
** of the use of varargs
**
** valid calls:
** tenFiberStopSet(tfx, tenFiberStopLength, double max)
** tenFiberStopSet(tfx, tenFiberStopMinLength, double min)
** tenFiberStopSet(tfx, tenFiberStopAniso, int anisoType, double anisoThresh)
** tenFiberStopSet(tfx, tenFiberStopNumSteps, unsigned int num)
** tenFiberStopSet(tfx, tenFiberStopMinNumSteps, unsigned int num)
** tenFiberStopSet(tfx, tenFiberStopConfidence, double conf)
** tenFiberStopSet(tfx, tenFiberStopRadius, double radius)
** tenFiberStopSet(tfx, tenFiberStopBounds)
** tenFiberStopSet(tfx, tenFiberStopFraction, double fraction)
** tenFiberStopSet(tfx, tenFiberStopStub)
*/
int
tenFiberStopSet(tenFiberContext *tfx, int stop, ...) {
char me[]="tenFiberStopSet", err[BIFF_STRLEN];
va_list ap;
int ret=0;
int anisoGage;
if (!tfx) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(TEN, err); return 1;
}
va_start(ap, stop);
switch(stop) {
case tenFiberStopAniso:
tfx->anisoStopType = va_arg(ap, int);
tfx->anisoThresh = va_arg(ap, double);
if (!(AIR_IN_OP(tenAnisoUnknown, tfx->anisoStopType, tenAnisoLast))) {
sprintf(err, "%s: given aniso stop type %d not valid", me,
tfx->anisoStopType);
biffAdd(TEN, err); ret = 1; goto end;
}
if (!(AIR_EXISTS(tfx->anisoThresh))) {
sprintf(err, "%s: given aniso threshold doesn't exist", me);
biffAdd(TEN, err); ret = 1; goto end;
}
if (tfx->useDwi) {
/* the tensor of which we measure anisotropy can come from lots of
places, not just a 1-tensor gage item, so there's no specific
item to turn on here... */
tfx->gageAnisoStop = NULL;
} else { /* using tensors */
switch(tfx->anisoStopType) {
case tenAniso_FA:
anisoGage = tenGageFA;
break;
case tenAniso_Cl1:
anisoGage = tenGageCl1;
break;
case tenAniso_Cp1:
anisoGage = tenGageCp1;
break;
case tenAniso_Ca1:
anisoGage = tenGageCa1;
break;
case tenAniso_Clpmin1:
anisoGage = tenGageClpmin1;
break;
case tenAniso_Cl2:
anisoGage = tenGageCl2;
break;
case tenAniso_Cp2:
anisoGage = tenGageCp2;
break;
case tenAniso_Ca2:
anisoGage = tenGageCa2;
break;
case tenAniso_Clpmin2:
anisoGage = tenGageClpmin2;
break;
default:
sprintf(err, "%s: sorry, currently don't have fast %s computation "
"via gage", me, airEnumStr(tenAniso, tfx->anisoStopType));
biffAdd(TEN, err); ret = 1; goto end;
break;
}
/* NOTE: we are no longer computing ALL anisotropy measures ...
GAGE_QUERY_ITEM_ON(tfx->query, tenGageAniso);
*/
GAGE_QUERY_ITEM_ON(tfx->query, anisoGage);
tfx->gageAnisoStop = gageAnswerPointer(tfx->gtx, tfx->pvl, anisoGage);
/*
fprintf(stderr, "!%s: stopping on aniso %s < %g\n", me,
airEnumStr(tenAniso, tfx->anisoStopType), tfx->anisoThresh);
*/
}
break;
case tenFiberStopLength:
tfx->maxHalfLen = va_arg(ap, double);
if (!( AIR_EXISTS(tfx->maxHalfLen) && tfx->maxHalfLen > 0.0 )) {
sprintf(err, "%s: given maxHalfLen %g doesn't exist or isn't > 0.0",
me, tfx->maxHalfLen);
biffAdd(TEN, err); ret = 1; goto end;
}
/* no query modifications needed */
break;
case tenFiberStopMinLength:
tfx->minWholeLen = va_arg(ap, double);
if (!( AIR_EXISTS(tfx->minWholeLen) && tfx->minWholeLen >= 0.0 )) {
sprintf(err, "%s: given minWholeLen %g doesn't exist or isn't >= 0.0",
me, tfx->minWholeLen);
biffAdd(TEN, err); ret = 1; goto end;
}
/* no query modifications needed */
break;
case tenFiberStopNumSteps:
tfx->maxNumSteps = va_arg(ap, unsigned int);
if (!( tfx->maxNumSteps > 0 )) {
sprintf(err, "%s: given maxNumSteps isn't > 0.0", me);
biffAdd(TEN, err); ret = 1; goto end;
}
/* no query modifications needed */
break;
case tenFiberStopMinNumSteps:
tfx->minNumSteps = va_arg(ap, unsigned int);
/* no query modifications needed */
break;
case tenFiberStopConfidence:
tfx->confThresh = va_arg(ap, double);
if (!( AIR_EXISTS(tfx->confThresh) )) {
sprintf(err, "%s: given confThresh doesn't exist", me);
biffAdd(TEN, err); ret = 1; goto end;
}
GAGE_QUERY_ITEM_ON(tfx->query, tenGageTensor);
break;
case tenFiberStopRadius:
tfx->minRadius = va_arg(ap, double);
if (!( AIR_EXISTS(tfx->minRadius) )) {
sprintf(err, "%s: given minimum radius doesn't exist", me);
biffAdd(TEN, err); ret = 1; goto end;
}
/* no query modifications needed */
break;
case tenFiberStopBounds:
/* nothing to set; always used as a stop criterion */
break;
case tenFiberStopFraction:
if (!tfx->useDwi) {
sprintf(err, "%s: can only use %s-based termination in DWI tractography",
me, airEnumStr(tenFiberStop, tenFiberStopFraction));
biffAdd(TEN, err); ret = 1; goto end;
}
tfx->minFraction = va_arg(ap, double);
if (!( AIR_EXISTS(tfx->minFraction) )) {
sprintf(err, "%s: given minimum fraction doesn't exist", me);
biffAdd(TEN, err); ret = 1; goto end;
}
/* no query modifications needed */
break;
case tenFiberStopStub:
/* no var-args to grab */
/* no query modifications needed */
break;
default:
sprintf(err, "%s: stop criterion %d not recognized", me, stop);
biffAdd(TEN, err); ret = 1; goto end;
}
tfx->stop = tfx->stop | (1 << stop);
end:
va_end(ap);
return ret;
}
int
nrrdProject(Nrrd *nout, const Nrrd *nin, unsigned int axis,
int measr, int type) {
char me[]="nrrdProject", func[]="project", err[BIFF_STRLEN];
int iType, oType, axmap[NRRD_DIM_MAX];
unsigned int ai, ei;
size_t iElSz, oElSz, iSize[NRRD_DIM_MAX], oSize[NRRD_DIM_MAX], linLen,
rowIdx, rowNum, colIdx, colNum, colStep;
const char *ptr, *iData;
char *oData, *line;
double axmin, axmax;
airArray *mop;
if (!(nin && nout)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(NRRD, err); return 1;
}
if (nout == nin) {
sprintf(err, "%s: nout==nin disallowed", me);
biffAdd(NRRD, err); return 1;
}
if (nrrdTypeBlock == nin->type) {
sprintf(err, "%s: can't project nrrd type %s", me,
airEnumStr(nrrdType, nrrdTypeBlock));
biffAdd(NRRD, err); return 1;
}
if (!AIR_IN_OP(nrrdMeasureUnknown, measr, nrrdMeasureLast)) {
sprintf(err, "%s: measure %d not recognized", me, measr);
biffAdd(NRRD, err); return 1;
}
/* without this check, the loops below cause segfaults, because
nin->dim is now unsigned */
if (!( 2 <= nin->dim )) {
sprintf(err, "%s: sorry, currently need at least 2-D array to project", me);
biffAdd(NRRD, err); return 1;
}
/* HEY: at some point, as a convenience, it would be nice to handle
projecting a single 1-D scanline down into a 1-D single-sample,
even though this would clearly be a special case */
if (!( axis <= nin->dim-1 )) {
sprintf(err, "%s: axis %d not in range [0,%d]", me, axis, nin->dim-1);
biffAdd(NRRD, err); return 1;
}
if (nrrdTypeDefault != type) {
if (!( AIR_IN_OP(nrrdTypeUnknown, type, nrrdTypeLast) )) {
sprintf(err, "%s: got invalid target type %d", me, type);
biffAdd(NRRD, err); return 1;
}
}
mop = airMopNew();
iType = nin->type;
oType = (nrrdTypeDefault != type
? type
: _nrrdMeasureType(nin, measr));
iElSz = nrrdTypeSize[iType];
oElSz = nrrdTypeSize[oType];
nrrdAxisInfoGet_nva(nin, nrrdAxisInfoSize, iSize);
colNum = rowNum = 1;
for (ai=0; ai<nin->dim; ai++) {
if (ai < axis) {
colNum *= iSize[ai];
} else if (ai > axis) {
rowNum *= iSize[ai];
}
}
linLen = iSize[axis];
colStep = linLen*colNum;
for (ai=0; ai<=nin->dim-2; ai++) {
axmap[ai] = ai + (ai >= axis);
}
for (ai=0; ai<=nin->dim-2; ai++) {
oSize[ai] = iSize[axmap[ai]];
}
if (nrrdMaybeAlloc_nva(nout, oType, nin->dim-1, oSize)) {
sprintf(err, "%s: failed to create output", me);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
/* allocate a scanline buffer */
if (!(line = (char*)calloc(linLen, iElSz))) {
sprintf(err, "%s: couldn't calloc(" _AIR_SIZE_T_CNV ","
_AIR_SIZE_T_CNV ") scanline buffer",
me, linLen, iElSz);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
airMopAdd(mop, line, airFree, airMopAlways);
/* the skinny */
axmin = nin->axis[axis].min;
axmax = nin->axis[axis].max;
iData = (char *)nin->data;
oData = (char *)nout->data;
for (rowIdx=0; rowIdx<rowNum; rowIdx++) {
for (colIdx=0; colIdx<colNum; colIdx++) {
ptr = iData + iElSz*(colIdx + rowIdx*colStep);
for (ei=0; ei<linLen; ei++) {
memcpy(line + ei*iElSz, ptr + ei*iElSz*colNum, iElSz);
}
nrrdMeasureLine[measr](oData, oType, line, iType, linLen,
axmin, axmax);
oData += oElSz;
}
}
/* copy the peripheral information */
if (nrrdAxisInfoCopy(nout, nin, axmap, NRRD_AXIS_INFO_NONE)) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
if (nrrdContentSet_va(nout, func, nin,
"%d,%s", axis, airEnumStr(nrrdMeasure, measr))) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
/* this will copy the space origin over directly, which is reasonable */
if (nrrdBasicInfoCopy(nout, nin,
NRRD_BASIC_INFO_DATA_BIT
| NRRD_BASIC_INFO_TYPE_BIT
| NRRD_BASIC_INFO_BLOCKSIZE_BIT
| NRRD_BASIC_INFO_DIMENSION_BIT
| NRRD_BASIC_INFO_CONTENT_BIT
| NRRD_BASIC_INFO_COMMENTS_BIT
| (nrrdStateKeyValuePairsPropagate
? 0
: NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT))) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); airMopError(mop); return 1;
}
airMopOkay(mop);
return 0;
}
int
main(int argc, char *argv[]) {
char *me, *outS;
hestOpt *hopt;
hestParm *hparm;
airArray *mop;
char *err;
Nrrd *nin, *nhist;
double vmin, vmax, rmax, val, cent[2], rad;
int bins[2], sx, sy, xi, yi, ridx, hidx, rbins, hbins;
NrrdRange *range;
double (*lup)(const void *v, size_t I), *hist;
me = argv[0];
mop = airMopNew();
hparm = hestParmNew();
hopt = NULL;
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
"input image", NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "b", "rbins hbins", airTypeInt, 2, 2, bins, NULL,
"# of histogram bins: radial and value");
hestOptAdd(&hopt, "min", "value", airTypeDouble, 1, 1, &vmin, "nan",
"Value at low end of histogram. Defaults to lowest value "
"found in input nrrd.");
hestOptAdd(&hopt, "max", "value", airTypeDouble, 1, 1, &vmax, "nan",
"Value at high end of histogram. Defaults to highest value "
"found in input nrrd.");
hestOptAdd(&hopt, "rmax", "max radius", airTypeDouble, 1, 1, &rmax, "nan",
"largest radius to include in histogram");
hestOptAdd(&hopt, "c", "center x, y", airTypeDouble, 2, 2, cent, NULL,
"The center point around which to build radial histogram");
hestOptAdd(&hopt, "o", "filename", airTypeString, 1, 1, &outS, "-",
"file to write histogram to");
hestParseOrDie(hopt, argc-1, argv+1, hparm,
me, histradInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
if (2 != nin->dim) {
fprintf(stderr, "%s: need 2-D input (not %d-D)\n", me, nin->dim);
airMopError(mop); return 1;
}
rbins = bins[0];
hbins = bins[1];
nhist = nrrdNew();
airMopAdd(mop, nhist, (airMopper)nrrdNuke, airMopAlways);
if (nrrdMaybeAlloc_va(nhist, nrrdTypeDouble, 2,
AIR_CAST(size_t, rbins),
AIR_CAST(size_t, hbins))) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't allocate histogram:\n%s", me, err);
airMopError(mop); return 1;
}
if (!( AIR_EXISTS(vmin) && AIR_EXISTS(vmax) )) {
range = nrrdRangeNewSet(nin, nrrdStateBlind8BitRange);
airMopAdd(mop, range, (airMopper)nrrdRangeNix, airMopAlways);
vmin = AIR_EXISTS(vmin) ? vmin : range->min;
vmax = AIR_EXISTS(vmax) ? vmax : range->max;
}
#define DIST(x0, y0, x1, y1) (sqrt((x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)))
sx = nin->axis[0].size;
sy = nin->axis[1].size;
if (!AIR_EXISTS(rmax)) {
rmax = 0;
rmax = AIR_MAX(rmax, DIST(cent[0], cent[1], 0, 0));
rmax = AIR_MAX(rmax, DIST(cent[0], cent[1], sx-1, 0));
rmax = AIR_MAX(rmax, DIST(cent[0], cent[1], 0, sy-1));
rmax = AIR_MAX(rmax, DIST(cent[0], cent[1], sx-1, sy-1));
}
lup = nrrdDLookup[nin->type];
hist = (double*)(nhist->data);
for (xi=0; xi<sx; xi++) {
for (yi=0; yi<sy; yi++) {
rad = DIST(cent[0], cent[1], xi, yi);
if (!AIR_IN_OP(0, rad, rmax)) {
continue;
}
val = lup(nin->data, xi + sx*yi);
if (!AIR_IN_OP(vmin, val, vmax)) {
continue;
}
ridx = airIndex(0, rad, rmax, rbins);
hidx = airIndex(vmin, val, vmax, hbins);
hist[ridx + rbins*hidx] += 1;
}
}
nhist->axis[0].min = 0;
nhist->axis[0].max = rmax;
nhist->axis[1].min = vmin;
nhist->axis[1].max = vmax;
if (nrrdSave(outS, nhist, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: couldn't save output:\n%s", me, err);
airMopError(mop); return 1;
}
airMopOkay(mop);
exit(0);
}
static double _nrrdTernaryOpInOpen(double a, double b, double c) {
return (AIR_IN_OP(a, b, c));
}
int
_echoRayIntx_Superquad(RAYINTX_ARGS(Superquad)) {
char me[]="_echoRayIntx_Superquad";
echoPos_t TT=0, Tmin, Tmax, t0, t1, t2, t3, v1, v2, diff, tol,
saveTmin, Vmin, Vmax, VV=0, dV, dVmin, dVmax, tmp,
(*v)(echoPos_t, echoPos_t, echoPos_t,
echoPos_t, echoPos_t),
(*vg)(echoPos_t[3],
echoPos_t, echoPos_t, echoPos_t,
echoPos_t, echoPos_t),
(*lvg)(echoPos_t[3],
echoPos_t, echoPos_t, echoPos_t,
echoPos_t, echoPos_t),
from[3], grad[3], pos[3]; /* these two used only by macros */
int iter;
if (!_echoRayIntx_CubeSolid(&Tmin, &Tmax,
-1-2*ECHO_EPSILON, 1+2*ECHO_EPSILON,
-1-2*ECHO_EPSILON, 1+2*ECHO_EPSILON,
-1-2*ECHO_EPSILON, 1+2*ECHO_EPSILON, ray)) {
return AIR_FALSE;
}
switch(obj->axis) {
case 0:
v = _echo_SuperquadX_v;
vg = _echo_SuperquadX_vg;
lvg = _echo_SuperquadX_lvg;
break;
case 1:
v = _echo_SuperquadY_v;
vg = _echo_SuperquadY_vg;
lvg = _echo_SuperquadY_lvg;
break;
case 2: default:
v = _echo_SuperquadZ_v;
vg = _echo_SuperquadZ_vg;
lvg = _echo_SuperquadZ_lvg;
break;
}
if (tstate->verbose) {
fprintf(stderr, "%s%s: Tmin, Tmax = %g, %g, ax = %d\n",
_echoDot(tstate->depth), me, Tmin, Tmax, obj->axis);
}
#define VAL(TT) \
(ELL_3V_SCALE_ADD2(pos, 1, from, (TT), ray->dir), \
v(pos[0], pos[1], pos[2], obj->A, obj->B))
#define VALGRAD(VV, DV, TT) \
ELL_3V_SCALE_ADD2(pos, 1, from, (TT), ray->dir); \
(VV) = vg(grad, pos[0], pos[1], pos[2], obj->A, obj->B); \
(DV) = ELL_3V_DOT(grad, ray->dir)
#define LVALGRAD(VV, DV, TT) \
ELL_3V_SCALE_ADD2(pos, 1, from, (TT), ray->dir); \
(VV) = lvg(grad, pos[0], pos[1], pos[2], obj->A, obj->B); \
(DV) = ELL_3V_DOT(grad, ray->dir)
#define RR 0.61803399
#define CC (1.0-RR)
#define SHIFT3(a,b,c,d) (a)=(b); (b)=(c); (c)=(d)
#define SHIFT2(a,b,c) (a)=(b); (b)=(c)
/* testing */
ELL_3V_SCALE_ADD2(from, 1, ray->from, Tmin, ray->dir);
saveTmin = Tmin;
Tmin = 0;
Tmax -= saveTmin;
/*
ELL_3V_COPY(from, ray->from);
saveTmin = 0;
*/
/* evaluate value and derivatives at Tmin and Tmax */
VALGRAD(Vmin, dVmin, Tmin);
VALGRAD(Vmax, dVmax, Tmax);
/* if the segment start and end are both positive or both negative,
and if the derivatives also don't change sign, there's no root.
Also, due to convexity, if values at start and end are negative,
then there is no root */
if ( (Vmin*Vmax >= 0 && dVmin*dVmax >= 0)
|| (Vmin <= 0 && Vmax <= 0) ) {
return AIR_FALSE;
}
if (tstate->verbose) {
fprintf(stderr, "%s%s: dVmin = %g, dVmax = %g, Vmin = %g, Vmax = %g\n",
_echoDot(tstate->depth), me, dVmin, dVmax, Vmin, Vmax);
}
/* either the value changed sign, or the derivative changed sign, or
both. If, as is common, the derivatives changed sign, but the
values didn't (which means they are both positive, due to a test
above), we need to limit the interval by minimizing the value
until either we see a negative value, or until the minimization
converged. Based on Golden Section Search, NR pg.401 */
if (dVmin*dVmax < 0 && Vmin*Vmax >= 0) {
t0 = Tmin;
t1 = RR*Tmin + CC*Tmax;
t2 = CC*Tmin + RR*Tmax;
t3 = Tmax;
v1 = VAL(t1);
v2 = VAL(t2);
if (tstate->verbose) {
fprintf(stderr, "%s%s: \n"
" t0 = % 31.15f\n"
" t1 = % 31.15f -> v1 = % 31.15f\n"
" t2 = % 31.15f -> v2 = % 31.15f\n"
" t3 = % 31.15f\n",
_echoDot(tstate->depth), me,
t0, t1, v1, t2, v2, t3);
}
tol = sqrt(ECHO_POS_EPS);
while ( (t3-t0 > tol*(t1+t2)) /* still haven't converged */
&& (v1 > 0 && v2 > 0) ) { /* v1 and v2 both positive */
diff = v2 - v1;
if (v1 < v2) {
SHIFT3(t3, t2, t1, CC*t0 + RR*t2);
SHIFT2(v2, v1, VAL(t1));
} else {
SHIFT3(t0, t1, t2, RR*t1 + CC*t3);
SHIFT2(v1, v2, VAL(t2));
}
if (tstate->verbose) {
fprintf(stderr, "%s%s: %s ---> \n"
" t0 = % 31.15f\n"
" t1 = % 31.15f -> v1 = % 31.15f\n"
" t2 = % 31.15f -> v2 = % 31.15f\n"
" t3 = % 31.15f\n",
_echoDot(tstate->depth), me,
diff > 0 ? "v1 < v2" : "v1 > v2",
t0, t1, v1, t2, v2, t3);
}
}
if (v1 > 0 && v2 > 0) {
/* the minimization stopped, yet both v1 and v2 are still positive,
so there's no way we can have a root */
if (tstate->verbose) {
fprintf(stderr, "%s%s: minimization found no root\n",
_echoDot(tstate->depth), me);
}
return AIR_FALSE;
}
/* else either v1 or v2 <= 0, so there is a root (actually two).
By construction, f(t0) is positive, so we can now bracket the
root between t0 and t1 or t2, whichever one is associated with
a smaller value */
Tmin = t0;
Tmax = v1 < v2 ? t1 : t2; /* HEY: shouldn't I just be using whichever one is closer? */
Vmin = VAL(Tmin);
Vmax = VAL(Tmax);
}
/* the value isn't necessarily monotonic between Tmin and Tmax, but
we know that there is only one root. Find it with newton-raphson,
using the log of function, both for values and for derivatives */
iter = 0;
TT = (Tmin + Tmax)/2;
LVALGRAD(VV, dV, TT);
while (iter < parm->sqNRI && AIR_ABS(VV) > parm->sqTol
&& AIR_EXISTS(VV) && AIR_EXISTS(dV)) {
if (tstate->verbose) {
fprintf(stderr, "%s%s: iter = %d: TT = %g, VV = %g, dV = %g\n",
_echoDot(tstate->depth), me, iter, TT, VV, dV);
}
TT -= VV/dV;
if (!AIR_IN_OP(Tmin, TT, Tmax)) {
/* newton-raphson sent us flying out of bounds; find a tighter
[Tmin,Tmax] bracket with bisection and try again */
TT = (Tmin + Tmax)/2;
VV = VAL(TT);
if (Vmin*VV < 0) {
Tmax = TT;
Vmax = VV;
} else {
Tmin = TT;
Vmin = VV;
}
TT = (Tmin + Tmax)/2;
}
LVALGRAD(VV, dV, TT);
iter++;
}
if (!( AIR_EXISTS(VV) && AIR_EXISTS(dV) )) {
/* we bailed out of the loop above because
we got screwed by numerical errors
--> pretend that there was no intersection,
and HEY this will have to be debugged later */
return AIR_FALSE;
}
/* else we succeedded in finding the intersection */
intx->t = TT + saveTmin;
VALGRAD(VV, dV, TT); /* puts gradient into grad */
ELL_3V_NORM(intx->norm, grad, tmp);
intx->obj = OBJECT(obj);
/* set in intx:
yes: t, norm
no: u, v
*/
return AIR_TRUE;
}
/*
******** nrrdAxisInfoSet_nva()
**
** Simple means of setting fields of the axis array in the nrrd.
**
** type to pass for third argument:
** nrrdAxisInfoSize: size_t*
** nrrdAxisInfoSpacing: double*
** nrrdAxisInfoThickness: double*
** nrrdAxisInfoMin: double*
** nrrdAxisInfoMax: double*
** nrrdAxisInfoSpaceDirection: double (*var)[NRRD_SPACE_DIM_MAX]
** nrrdAxisInfoCenter: int*
** nrrdAxisInfoKind: int*
** nrrdAxisInfoLabel: char**
** nrrdAxisInfoUnits: char**
*/
void
nrrdAxisInfoSet_nva(Nrrd *nrrd, int axInfo, const void *_info) {
_nrrdAxisInfoSetPtrs info;
int exists;
unsigned int ai, si, minsi;
if (!( nrrd
&& AIR_IN_CL(1, nrrd->dim, NRRD_DIM_MAX)
&& AIR_IN_OP(nrrdAxisInfoUnknown, axInfo, nrrdAxisInfoLast)
&& _info )) {
return;
}
info.P = _info;
for (ai=0; ai<nrrd->dim; ai++) {
switch (axInfo) {
case nrrdAxisInfoSize:
nrrd->axis[ai].size = info.ST[ai];
break;
case nrrdAxisInfoSpacing:
nrrd->axis[ai].spacing = info.D[ai];
break;
case nrrdAxisInfoThickness:
nrrd->axis[ai].thickness = info.D[ai];
break;
case nrrdAxisInfoMin:
nrrd->axis[ai].min = info.D[ai];
break;
case nrrdAxisInfoMax:
nrrd->axis[ai].max = info.D[ai];
break;
case nrrdAxisInfoSpaceDirection:
/* we won't allow setting an invalid direction */
exists = AIR_EXISTS(info.V[ai][0]);
minsi = nrrd->spaceDim;
for (si=0; si<nrrd->spaceDim; si++) {
nrrd->axis[ai].spaceDirection[si] = info.V[ai][si];
if (exists ^ AIR_EXISTS(info.V[ai][si])) {
minsi = 0;
break;
}
}
for (si=minsi; si<NRRD_SPACE_DIM_MAX; si++) {
nrrd->axis[ai].spaceDirection[si] = AIR_NAN;
}
break;
case nrrdAxisInfoCenter:
nrrd->axis[ai].center = info.I[ai];
break;
case nrrdAxisInfoKind:
nrrd->axis[ai].kind = info.I[ai];
break;
case nrrdAxisInfoLabel:
nrrd->axis[ai].label = (char *)airFree(nrrd->axis[ai].label);
nrrd->axis[ai].label = (char *)airStrdup(info.CP[ai]);
break;
case nrrdAxisInfoUnits:
nrrd->axis[ai].units = (char *)airFree(nrrd->axis[ai].units);
nrrd->axis[ai].units = (char *)airStrdup(info.CP[ai]);
break;
}
}
if (nrrdAxisInfoSpaceDirection == axInfo) {
for (ai=nrrd->dim; ai<NRRD_DIM_MAX; ai++) {
for (si=0; si<NRRD_SPACE_DIM_MAX; si++) {
nrrd->axis[ai].spaceDirection[si] = AIR_NAN;
}
}
}
return;
}
/*
******** limnCameraUpdate()
**
** sets in cam: W2V, V2W, U, V, N, vspNeer, vspFaar, vspDist
** and, if fov and aspect are set, this also sets uRange and vRange
**
** This does use biff to describe problems with camera settings
*/
int
limnCameraUpdate(limnCamera *cam) {
static const char me[] = "limnCameraUpdate";
double len, bb[4], uu[4], vv[4], nn[4], TT[16], RR[16];
if (!cam) {
biffAddf(LIMN, "%s: got NULL pointer", me);
return 1;
}
ELL_4V_SET(uu, 0, 0, 0, 0);
ELL_4V_SET(vv, 0, 0, 0, 0);
ELL_4V_SET(nn, 0, 0, 0, 0);
ELL_4V_SET(bb, 0, 0, 0, 1);
ELL_3V_SUB(nn, cam->at, cam->from);
len = ELL_3V_LEN(nn);
if (!len) {
biffAddf(LIMN, "%s: cam->at (%g,%g,%g) == cam->from", me,
cam->at[0], cam->at[1], cam->at[2]);
return 1;
}
if (cam->atRelative) {
/* ctx->cam->{neer,dist} are "at" relative */
cam->vspNeer = cam->neer + len;
cam->vspFaar = cam->faar + len;
cam->vspDist = cam->dist + len;
}
else {
/* ctx->cam->{neer,dist} are eye relative */
cam->vspNeer = cam->neer;
cam->vspFaar = cam->faar;
cam->vspDist = cam->dist;
}
if (!(cam->vspNeer > 0 && cam->vspDist > 0 && cam->vspFaar > 0)) {
biffAddf(LIMN, "%s: eye-relative near (%g), dist (%g), or far (%g) <= 0",
me, cam->vspNeer, cam->vspDist, cam->vspFaar);
return 1;
}
if (!(cam->vspNeer <= cam->vspFaar)) {
biffAddf(LIMN, "%s: eye-relative near (%g) further than far (%g)",
me, cam->vspNeer, cam->vspFaar);
return 1 ;
}
if (AIR_EXISTS(cam->fov)) {
if (!( AIR_IN_OP(0.0, cam->fov, 180.0) )) {
biffAddf(LIMN, "%s: cam->fov (%g) not in valid range between 0 and 180",
me, cam->fov);
return 1 ;
}
if (!AIR_EXISTS(cam->aspect)) {
biffAddf(LIMN, "%s: cam->fov set, but cam->aspect isn't", me);
return 1;
}
/* "fov" is half vertical angle */
cam->vRange[0] = -tan(cam->fov*AIR_PI/360)*(cam->vspDist);
cam->vRange[1] = -cam->vRange[0];
cam->uRange[0] = cam->vRange[0]*(cam->aspect);
cam->uRange[1] = -cam->uRange[0];
}
/* else cam->fov isn't set, but we're not going to complain if
uRange and vRange aren't both set ... */
ELL_3V_SCALE(nn, 1.0/len, nn);
ELL_3V_CROSS(uu, nn, cam->up);
len = ELL_3V_LEN(uu);
if (!len) {
biffAddf(LIMN, "%s: cam->up is co-linear with view direction", me);
return 1 ;
}
ELL_3V_SCALE(uu, 1.0/len, uu);
if (cam->rightHanded) {
ELL_3V_CROSS(vv, nn, uu);
}
else {
ELL_3V_CROSS(vv, uu, nn);
}
ELL_4V_COPY(cam->U, uu);
ELL_4V_COPY(cam->V, vv);
ELL_4V_COPY(cam->N, nn);
ELL_4M_TRANSLATE_SET(TT, -cam->from[0], -cam->from[1], -cam->from[2]);
ELL_4M_ROWS_SET(RR, uu, vv, nn, bb);
ELL_4M_MUL(cam->W2V, RR, TT);
ell_4m_inv_d(cam->V2W, cam->W2V);
return 0;
}
/*
******** nrrdAxisInfoGet_nva()
**
** get any of the axis fields into an array
**
** Note that getting axes labels involves implicitly allocating space
** for them, due to the action of airStrdup(). The user is
** responsible for free()ing these strings when done with them.
**
** type to pass for third argument:
** nrrdAxisInfoSize: size_t*
** nrrdAxisInfoSpacing: double*
** nrrdAxisInfoThickness: double*
** nrrdAxisInfoMin: double*
** nrrdAxisInfoMax: double*
** nrrdAxisInfoSpaceDirection: double (*var)[NRRD_SPACE_DIM_MAX]
** nrrdAxisInfoCenter: int*
** nrrdAxisInfoKind: int*
** nrrdAxisInfoLabel: char**
** nrrdAxisInfoUnits: char**
*/
void
nrrdAxisInfoGet_nva(const Nrrd *nrrd, int axInfo, void *_info) {
_nrrdAxisInfoGetPtrs info;
unsigned int ai, si;
if (!( nrrd
&& AIR_IN_CL(1, nrrd->dim, NRRD_DIM_MAX)
&& AIR_IN_OP(nrrdAxisInfoUnknown, axInfo, nrrdAxisInfoLast) )) {
return;
}
info.P = _info;
for (ai=0; ai<nrrd->dim; ai++) {
switch (axInfo) {
case nrrdAxisInfoSize:
info.ST[ai] = nrrd->axis[ai].size;
break;
case nrrdAxisInfoSpacing:
info.D[ai] = nrrd->axis[ai].spacing;
break;
case nrrdAxisInfoThickness:
info.D[ai] = nrrd->axis[ai].thickness;
break;
case nrrdAxisInfoMin:
info.D[ai] = nrrd->axis[ai].min;
break;
case nrrdAxisInfoMax:
info.D[ai] = nrrd->axis[ai].max;
break;
case nrrdAxisInfoSpaceDirection:
for (si=0; si<nrrd->spaceDim; si++) {
info.V[ai][si] = nrrd->axis[ai].spaceDirection[si];
}
for (si=nrrd->spaceDim; si<NRRD_SPACE_DIM_MAX; si++) {
info.V[ai][si] = AIR_NAN;
}
break;
case nrrdAxisInfoCenter:
info.I[ai] = nrrd->axis[ai].center;
break;
case nrrdAxisInfoKind:
info.I[ai] = nrrd->axis[ai].kind;
break;
case nrrdAxisInfoLabel:
/* note airStrdup()! */
info.CP[ai] = airStrdup(nrrd->axis[ai].label);
break;
case nrrdAxisInfoUnits:
/* note airStrdup()! */
info.CP[ai] = airStrdup(nrrd->axis[ai].units);
break;
}
}
if (nrrdAxisInfoSpaceDirection == axInfo) {
for (ai=nrrd->dim; ai<NRRD_DIM_MAX; ai++) {
for (si=0; si<NRRD_SPACE_DIM_MAX; si++) {
info.V[ai][si] = AIR_NAN;
}
}
}
return;
}
/*
** _nrrdSprintFieldInfo
**
** this prints "<prefix><field>: <info>" into *strP (after allocating it for
** big enough, usually with a stupidly big margin of error), in a form
** suitable to be written to NRRD or other image headers. This will always
** print something (for valid inputs), even stupid <info>s like
** "(unknown endian)". It is up to the caller to decide which fields
** are worth writing, via _nrrdFieldInteresting().
**
** NOTE: some of these fields make sense in non-NRRD files (e.g. all
** the per-axis information), but many only make sense in NRRD files.
** This is just one example of NRRD-format-specific stuff that is not
** in formatNRRD.c
*/
void
_nrrdSprintFieldInfo(char **strP, const char *prefix,
const Nrrd *nrrd, NrrdIoState *nio, int field) {
static const char me[]="_nrrdSprintFieldInfo";
char buff[AIR_STRLEN_MED], *fnb, stmp[AIR_STRLEN_SMALL],
*strtmp=NULL;
double colvec[NRRD_SPACE_DIM_MAX];
const char *fs;
unsigned int ii, dd,
uintStrlen = 11,
size_tStrlen = 33,
doubleStrlen = 513;
size_t fslen, fdlen, maxl;
int endi;
if (!( strP && prefix
&& nrrd
&& AIR_IN_CL(1, nrrd->dim, NRRD_DIM_MAX)
&& AIR_IN_OP(nrrdField_unknown, field, nrrdField_last) )) {
return;
}
/* As of Sun Dec 2 01:57:48 CST 2012 (revision 5832) the only
places where this function is called is when it has been guarded
by "if (_nrrdFieldInteresting())" (except for in formatText.c when
its called on the dimension field, which is always interesting).
So, the following:
if (!_nrrdFieldInteresting(nrrd, nio, field)) {
*strP = airStrdup("");
}
was redundant and confusingly created the appearance of a memory
leak waiting to happen. We now let the default switch statement
set *strP to NULL (all the other cases set it), to smoke out
errors in how this function is called */
fs = airEnumStr(nrrdField, field);
fslen = strlen(prefix) + strlen(fs) + strlen(": ") + 1;
switch (field) {
case nrrdField_comment:
case nrrdField_keyvalue:
fprintf(stderr, "%s: CONFUSION: why are you calling me on \"%s\"?\n", me,
airEnumStr(nrrdField, nrrdField_comment));
*strP = airStrdup("");
break;
case nrrdField_content:
strtmp = airOneLinify(airStrdup(nrrd->content));
*strP = AIR_CALLOC(fslen + strlen(strtmp), char);
sprintf(*strP, "%s%s: %s", prefix, fs, strtmp);
airFree(strtmp); strtmp = NULL;
break;
case nrrdField_number:
*strP = AIR_CALLOC(fslen + size_tStrlen, char);
sprintf(*strP, "%s%s: %s", prefix, fs,
airSprintSize_t(stmp, nrrdElementNumber(nrrd)));
break;
case nrrdField_type:
*strP = AIR_CALLOC(fslen + strlen(airEnumStr(nrrdType, nrrd->type)), char);
sprintf(*strP, "%s%s: %s", prefix, fs, airEnumStr(nrrdType, nrrd->type));
break;
case nrrdField_block_size:
*strP = AIR_CALLOC(fslen + size_tStrlen, char);
sprintf(*strP, "%s%s: %s", prefix, fs,
airSprintSize_t(stmp, nrrd->blockSize));
break;
case nrrdField_dimension:
*strP = AIR_CALLOC(fslen + uintStrlen, char);
sprintf(*strP, "%s%s: %d", prefix, fs, nrrd->dim);
break;
case nrrdField_space:
*strP = AIR_CALLOC(fslen
+ strlen(airEnumStr(nrrdSpace, nrrd->space)), char);
sprintf(*strP, "%s%s: %s", prefix, fs, airEnumStr(nrrdSpace, nrrd->space));
break;
case nrrdField_space_dimension:
*strP = AIR_CALLOC(fslen + uintStrlen, char);
sprintf(*strP, "%s%s: %d", prefix, fs, nrrd->spaceDim);
break;
/* ---- begin per-axis fields ---- */
case nrrdField_sizes:
*strP = AIR_CALLOC(fslen + nrrd->dim*(size_tStrlen + 1), char);
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++) {
sprintf(buff, " %s", airSprintSize_t(stmp, nrrd->axis[ii].size));
strcat(*strP, buff);
}
break;
case nrrdField_spacings:
*strP = AIR_CALLOC(fslen + nrrd->dim*(doubleStrlen + 1), char);
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++) {
airSinglePrintf(NULL, buff, " %.17g", nrrd->axis[ii].spacing);
strcat(*strP, buff);
}
break;
case nrrdField_thicknesses:
*strP = AIR_CALLOC(fslen + nrrd->dim*(doubleStrlen + 1), char);
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++) {
airSinglePrintf(NULL, buff, " %.17g", nrrd->axis[ii].thickness);
strcat(*strP, buff);
}
break;
case nrrdField_axis_mins:
*strP = AIR_CALLOC(fslen + nrrd->dim*(doubleStrlen + 1), char);
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++) {
airSinglePrintf(NULL, buff, " %.17g", nrrd->axis[ii].min);
strcat(*strP, buff);
}
break;
case nrrdField_axis_maxs:
*strP = AIR_CALLOC(fslen + nrrd->dim*(doubleStrlen + 1), char);
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++) {
airSinglePrintf(NULL, buff, " %.17g", nrrd->axis[ii].max);
strcat(*strP, buff);
}
break;
case nrrdField_space_directions:
*strP = AIR_CALLOC(fslen
+ nrrd->dim*nrrd->spaceDim*(doubleStrlen
+ strlen("(,) ")), char);
sprintf(*strP, "%s%s: ", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++) {
_nrrdStrcatSpaceVector(*strP, nrrd->spaceDim,
nrrd->axis[ii].spaceDirection);
if (ii < nrrd->dim-1) {
strcat(*strP, " ");
}
}
break;
case nrrdField_centers:
fdlen = 0;
for (ii=0; ii<nrrd->dim; ii++) {
fdlen += 1 + airStrlen(nrrd->axis[ii].center
? airEnumStr(nrrdCenter, nrrd->axis[ii].center)
: NRRD_UNKNOWN);
}
*strP = AIR_CALLOC(fslen + fdlen, char);
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++) {
sprintf(buff, " %s",
(nrrd->axis[ii].center
? airEnumStr(nrrdCenter, nrrd->axis[ii].center)
: NRRD_UNKNOWN));
strcat(*strP, buff);
}
break;
case nrrdField_kinds:
fdlen = 0;
for (ii=0; ii<nrrd->dim; ii++) {
fdlen += 1 + airStrlen(nrrd->axis[ii].kind
? airEnumStr(nrrdKind, nrrd->axis[ii].kind)
: NRRD_UNKNOWN);
}
*strP = AIR_CALLOC(fslen + fdlen, char);
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++) {
sprintf(buff, " %s",
(nrrd->axis[ii].kind
? airEnumStr(nrrdKind, nrrd->axis[ii].kind)
: NRRD_UNKNOWN));
strcat(*strP, buff);
}
break;
case nrrdField_labels:
case nrrdField_units:
#define LABEL_OR_UNITS (nrrdField_labels == field \
? nrrd->axis[ii].label \
: nrrd->axis[ii].units)
fdlen = 0;
for (ii=0; ii<nrrd->dim; ii++) {
/* The "2*" is because at worst every character needs escaping.
The "+ 3" for the |" "| between each part */
fdlen += 2*airStrlen(LABEL_OR_UNITS) + 3;
}
fdlen += 1; /* for '\0' */
*strP = AIR_CALLOC(fslen + fdlen, char);
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->dim; ii++) {
strcat(*strP, " \"");
if (airStrlen(nrrd->axis[ii].label)) {
_nrrdWriteEscaped(NULL, *strP, LABEL_OR_UNITS,
"\"", _NRRD_WHITESPACE_NOTAB);
}
strcat(*strP, "\"");
}
#undef LABEL_OR_UNITS
break;
/* ---- end per-axis fields ---- */
case nrrdField_min:
case nrrdField_max:
/* we're basically a no-op, now that these fields became meaningless */
*strP = AIR_CALLOC(fslen + doubleStrlen, char);
sprintf(*strP, "%s%s: 0.0", prefix, fs);
strcat(*strP, buff);
break;
case nrrdField_old_min:
*strP = AIR_CALLOC(fslen + doubleStrlen, char);
sprintf(*strP, "%s%s: ", prefix, fs);
airSinglePrintf(NULL, buff, "%.17g", nrrd->oldMin);
strcat(*strP, buff);
break;
case nrrdField_old_max:
*strP = AIR_CALLOC(fslen + doubleStrlen, char);
sprintf(*strP, "%s%s: ", prefix, fs);
airSinglePrintf(NULL, buff, "%.17g", nrrd->oldMax);
strcat(*strP, buff);
break;
case nrrdField_endian:
if (airEndianUnknown != nio->endian) {
/* we know a specific endianness because either it was recorded as
part of "unu make -h", or it was set (and data was possibly
altered) as part of "unu save" */
endi = nio->endian;
} else {
/* we record our current architecture's endian because we're
going to writing out data */
endi = airMyEndian();
}
*strP = AIR_CALLOC(fslen + strlen(airEnumStr(airEndian, endi)), char);
sprintf(*strP, "%s%s: %s", prefix, fs, airEnumStr(airEndian, endi));
break;
case nrrdField_encoding:
*strP = AIR_CALLOC(fslen + strlen(nio->encoding->name), char);
sprintf(*strP, "%s%s: %s", prefix, fs, nio->encoding->name);
break;
case nrrdField_line_skip:
*strP = AIR_CALLOC(fslen + uintStrlen, char);
sprintf(*strP, "%s%s: %d", prefix, fs, nio->lineSkip);
break;
case nrrdField_byte_skip:
*strP = AIR_CALLOC(fslen + uintStrlen, char);
sprintf(*strP, "%s%s: %ld", prefix, fs, nio->byteSkip);
break;
case nrrdField_sample_units:
strtmp = airOneLinify(airStrdup(nrrd->sampleUnits));
*strP = AIR_CALLOC(fslen + strlen(strtmp), char);
sprintf(*strP, "%s%s: \"%s\"", prefix, fs, strtmp);
airFree(strtmp); strtmp = NULL;
break;
case nrrdField_space_units:
fdlen = 0;
for (ii=0; ii<nrrd->spaceDim; ii++) {
/* The "2*" is because at worst every character needs escaping.
See note in formatNRRD.c about how even though its not part
of the format, we have worst-case scenario of having to
escape a space units which is nothing but ". The "+ 3" for
the |" "| between each part */
fdlen += 2*airStrlen(nrrd->spaceUnits[ii]) + 3;
}
fdlen += 1; /* for '\0' */
*strP = AIR_CALLOC(fslen + fdlen, char);
sprintf(*strP, "%s%s:", prefix, fs);
for (ii=0; ii<nrrd->spaceDim; ii++) {
strcat(*strP, " \"");
if (airStrlen(nrrd->spaceUnits[ii])) {
_nrrdWriteEscaped(NULL, *strP, nrrd->spaceUnits[ii],
"\"", _NRRD_WHITESPACE_NOTAB);
}
strcat(*strP, "\"");
}
break;
case nrrdField_space_origin:
*strP = AIR_CALLOC(fslen + nrrd->spaceDim*(doubleStrlen
+ strlen("(,) ")), char);
sprintf(*strP, "%s%s: ", prefix, fs);
_nrrdStrcatSpaceVector(*strP, nrrd->spaceDim, nrrd->spaceOrigin);
break;
case nrrdField_measurement_frame:
*strP = AIR_CALLOC(fslen + (nrrd->spaceDim*
nrrd->spaceDim*(doubleStrlen
+ strlen("(,) "))), char);
sprintf(*strP, "%s%s: ", prefix, fs);
for (dd=0; dd<nrrd->spaceDim; dd++) {
for (ii=0; ii<nrrd->spaceDim; ii++) {
colvec[ii] = nrrd->measurementFrame[dd][ii];
}
_nrrdStrcatSpaceVector(*strP, nrrd->spaceDim, colvec);
if (dd < nrrd->spaceDim-1) {
strcat(*strP, " ");
}
}
break;
case nrrdField_data_file:
/* NOTE: this comes last (nrrdField_data_file is the highest-valued
member of the nrrdField* enum) because the "LIST" form of the
data file specification requires that the following lines be
the filenames */
/* error checking elsewhere: assumes there is data file info */
if (nio->dataFNFormat) {
*strP = AIR_CALLOC(fslen + strlen(nio->dataFNFormat) + 4*uintStrlen,
char);
if (nio->dataFileDim == nrrd->dim-1) {
sprintf(*strP, "%s%s: %s %d %d %d", prefix, fs, nio->dataFNFormat,
nio->dataFNMin, nio->dataFNMax, nio->dataFNStep);
} else {
sprintf(*strP, "%s%s: %s %d %d %d %u", prefix, fs, nio->dataFNFormat,
nio->dataFNMin, nio->dataFNMax, nio->dataFNStep,
nio->dataFileDim);
}
} else if (nio->dataFNArr->len > 1) {
/*
******** nrrdKindSize
**
** returns suggested size (length) of an axis with the given kind, or,
** 0 if either (1) there is no suggested size because the axis is the
** kind of an independent or domain variable or (2) the kind is invalid
*/
unsigned int
nrrdKindSize(int kind) {
char me[]="nrrdKindSize";
int ret;
if (!( AIR_IN_OP(nrrdKindUnknown, kind, nrrdKindLast) )) {
/* they gave us invalid or unknown kind */
return 0;
}
switch (kind) {
case nrrdKindDomain:
case nrrdKindSpace:
case nrrdKindTime:
case nrrdKindList:
case nrrdKindPoint:
case nrrdKindVector:
case nrrdKindCovariantVector:
case nrrdKindNormal:
ret = 0;
break;
case nrrdKindStub:
case nrrdKindScalar:
ret = 1;
break;
case nrrdKindComplex:
case nrrdKind2Vector:
ret = 2;
break;
case nrrdKind3Color:
case nrrdKindRGBColor:
case nrrdKindHSVColor:
case nrrdKindXYZColor:
ret = 3;
break;
case nrrdKind4Color:
case nrrdKindRGBAColor:
ret = 4;
break;
case nrrdKind3Vector:
case nrrdKind3Normal:
ret = 3;
break;
case nrrdKind4Vector:
case nrrdKindQuaternion:
ret = 4;
break;
case nrrdKind2DSymMatrix:
ret = 3;
break;
case nrrdKind2DMaskedSymMatrix:
ret = 4;
break;
case nrrdKind2DMatrix:
ret = 4;
break;
case nrrdKind2DMaskedMatrix:
ret = 5;
break;
case nrrdKind3DSymMatrix:
ret = 6;
break;
case nrrdKind3DMaskedSymMatrix:
ret = 7;
break;
case nrrdKind3DMatrix:
ret = 9;
break;
case nrrdKind3DMaskedMatrix:
ret = 10;
break;
default:
fprintf(stderr, "%s: PANIC: nrrdKind %d not implemented!\n", me, kind);
exit(1);
}
return ret;
}
int
tenGlyphParmCheck(tenGlyphParm *parm,
const Nrrd *nten, const Nrrd *npos, const Nrrd *nslc) {
char me[]="tenGlyphParmCheck", err[BIFF_STRLEN];
int duh;
size_t tenSize[3];
if (!(parm && nten)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(TEN, err); return 1;
}
if (airEnumValCheck(tenAniso, parm->anisoType)) {
sprintf(err, "%s: unset (or invalid) anisoType (%d)", me, parm->anisoType);
biffAdd(TEN, err); return 1;
}
if (airEnumValCheck(tenAniso, parm->colAnisoType)) {
sprintf(err, "%s: unset (or invalid) colAnisoType (%d)",
me, parm->colAnisoType);
biffAdd(TEN, err); return 1;
}
if (!( parm->facetRes >= 3 )) {
sprintf(err, "%s: facet resolution %d not >= 3", me, parm->facetRes);
biffAdd(TEN, err); return 1;
}
if (!( AIR_IN_OP(tenGlyphTypeUnknown, parm->glyphType,
tenGlyphTypeLast) )) {
sprintf(err, "%s: unset (or invalid) glyphType (%d)", me, parm->glyphType);
biffAdd(TEN, err); return 1;
}
if (!( parm->glyphScale > 0)) {
sprintf(err, "%s: glyphScale must be > 0 (not %g)", me, parm->glyphScale);
biffAdd(TEN, err); return 1;
}
if (parm->nmask) {
if (npos) {
sprintf(err, "%s: can't do masking with explicit coordinate list", me);
biffAdd(TEN, err); return 1;
}
if (!( 3 == parm->nmask->dim
&& parm->nmask->axis[0].size == nten->axis[1].size
&& parm->nmask->axis[1].size == nten->axis[2].size
&& parm->nmask->axis[2].size == nten->axis[3].size )) {
sprintf(err, "%s: mask isn't 3-D or doesn't have sizes ("
_AIR_SIZE_T_CNV "," _AIR_SIZE_T_CNV "," _AIR_SIZE_T_CNV ")", me,
nten->axis[1].size, nten->axis[2].size, nten->axis[3].size);
biffAdd(TEN, err); return 1;
}
if (!(AIR_EXISTS(parm->maskThresh))) {
sprintf(err, "%s: maskThresh hasn't been set", me);
biffAdd(TEN, err); return 1;
}
}
if (!( AIR_EXISTS(parm->anisoThresh)
&& AIR_EXISTS(parm->confThresh) )) {
sprintf(err, "%s: anisoThresh and confThresh haven't both been set", me);
biffAdd(TEN, err); return 1;
}
if (parm->doSlice) {
if (npos) {
sprintf(err, "%s: can't do slice with explicit coordinate list", me);
biffAdd(TEN, err); return 1;
}
if (!( parm->sliceAxis <=2 )) {
sprintf(err, "%s: slice axis %d invalid", me, parm->sliceAxis);
biffAdd(TEN, err); return 1;
}
if (!( parm->slicePos < nten->axis[1+parm->sliceAxis].size )) {
sprintf(err, "%s: slice pos " _AIR_SIZE_T_CNV
" not in valid range [0.." _AIR_SIZE_T_CNV "]", me,
parm->slicePos, nten->axis[1+parm->sliceAxis].size-1);
biffAdd(TEN, err); return 1;
}
if (nslc) {
if (2 != nslc->dim) {
sprintf(err, "%s: explicit slice must be 2-D (not %d)", me, nslc->dim);
biffAdd(TEN, err); return 1;
}
tenSize[0] = nten->axis[1].size;
tenSize[1] = nten->axis[2].size;
tenSize[2] = nten->axis[3].size;
for (duh=parm->sliceAxis; duh<2; duh++) {
tenSize[duh] = tenSize[duh+1];
}
if (!( tenSize[0] == nslc->axis[0].size
&& tenSize[1] == nslc->axis[1].size )) {
sprintf(err, "%s: axis %u slice of "
_AIR_SIZE_T_CNV "x" _AIR_SIZE_T_CNV "x" _AIR_SIZE_T_CNV
" volume is not " _AIR_SIZE_T_CNV "x" _AIR_SIZE_T_CNV , me,
parm->sliceAxis, nten->axis[1].size, nten->axis[2].size,
nten->axis[3].size, nslc->axis[0].size, nslc->axis[1].size);
biffAdd(TEN, err); return 1;
}
} else {
if (airEnumValCheck(tenAniso, parm->sliceAnisoType)) {
sprintf(err, "%s: unset (or invalid) sliceAnisoType (%d)",
me, parm->sliceAnisoType);
biffAdd(TEN, err); return 1;
}
}
}
return 0;
}
