/*
******** nrrdSpaceSet
**
** What to use to set space, when a value from nrrdSpace enum is known,
** or, to nullify all space-related information when passed nrrdSpaceUnknown
*/
int
nrrdSpaceSet(Nrrd *nrrd, int space) {
static const char me[]="nrrdSpaceSet";
unsigned axi, saxi;
if (!nrrd) {
biffAddf(NRRD, "%s: got NULL pointer", me);
return 1;
}
if (nrrdSpaceUnknown == space) {
nrrd->space = nrrdSpaceUnknown;
nrrd->spaceDim = 0;
for (axi=0; axi<NRRD_DIM_MAX; axi++) {
nrrdSpaceVecSetNaN(nrrd->axis[axi].spaceDirection);
}
for (saxi=0; saxi<NRRD_SPACE_DIM_MAX; saxi++) {
airFree(nrrd->spaceUnits[saxi]);
nrrd->spaceUnits[saxi] = NULL;
}
nrrdSpaceVecSetNaN(nrrd->spaceOrigin);
} else {
if (airEnumValCheck(nrrdSpace, space)) {
biffAddf(NRRD, "%s: given space (%d) not valid", me, space);
return 1;
}
nrrd->space = space;
nrrd->spaceDim = nrrdSpaceDimension(space);
}
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;
}
int
unrrdu_dnormMain(int argc, const char **argv, const char *me,
hestParm *hparm) {
char *outS;
int pret;
Nrrd *nin, *nout;
NrrdIoState *nio;
int kindIn, kindOut, headerOnly, haveMM, trivialOrient, recenter, gotmf;
unsigned int kindAxis, axi, si, sj;
double sscl;
hestOpt *opt = NULL;
char *err;
airArray *mop;
hestOptAdd(&opt, "h,header", NULL, airTypeInt, 0, 0, &headerOnly, NULL,
"output header of nrrd file only, not the data itself");
hestOptAdd(&opt, "to", NULL, airTypeInt, 0, 0, &trivialOrient, NULL,
"(*t*rivial *o*rientation) "
"even if the input nrrd comes with full orientation or "
"per-axis min-max info, ignore it and instead assert the "
"identity mapping between index and world space");
hestOptAdd(&opt, "c,center", NULL, airTypeInt, 0, 0, &recenter, NULL,
"re-locate output spaceOrigin so that field is centered "
"around origin of space coordinates");
hestOptAdd(&opt, "s,scaling", "scl", airTypeDouble, 1, 1, &sscl, "1.0",
"when having to contrive orientation information and there's "
"no per-axis min/max to inform what the sample spacing is, "
"this is the sample spacing to assert");
OPT_ADD_NIN(nin, "input image");
OPT_ADD_NOUT(outS, "output filename");
mop = airMopNew();
airMopAdd(mop, opt, (airMopper)hestOptFree, airMopAlways);
USAGE(_unrrdu_dnormInfoL);
PARSE();
airMopAdd(mop, opt, (airMopper)hestParseFree, airMopAlways);
/* can't deal with block type */
if (nrrdTypeBlock == nin->type) {
fprintf(stderr, "%s: can only have scalar kinds (not %s)\n", me,
airEnumStr(nrrdType, nrrdTypeBlock));
airMopError(mop);
exit(1);
}
/* make sure all kinds are set to something */
/* see if there's a range kind, verify that there's only one */
/* set haveMM */
haveMM = AIR_TRUE;
kindIn = nrrdKindUnknown;
kindAxis = 0;
for (axi=0; axi<nin->dim; axi++) {
if (nrrdKindUnknown == nin->axis[axi].kind
|| nrrdKindIsDomain(nin->axis[axi].kind)) {
haveMM &= AIR_EXISTS(nin->axis[axi].min);
haveMM &= AIR_EXISTS(nin->axis[axi].max);
} else {
if (nrrdKindUnknown != kindIn) {
fprintf(stderr, "%s: got non-domain kind %s on axis %u, but already "
"have %s from axis %u\n", me,
airEnumStr(nrrdKind, nin->axis[axi].kind), axi,
airEnumStr(nrrdKind, kindIn), kindAxis);
airMopError(mop);
exit(1);
}
kindIn = nin->axis[axi].kind;
kindAxis = axi;
}
}
/* see if the non-domain kind is something we can interpret as a tensor */
if (nrrdKindUnknown != kindIn) {
switch (kindIn) {
/* ======= THESE are the kinds that we can possibly output ======= */
case nrrdKind2Vector:
case nrrdKind3Vector:
case nrrdKind4Vector:
case nrrdKind2DSymMatrix:
case nrrdKind2DMatrix:
case nrrdKind3DSymMatrix:
case nrrdKind3DMatrix:
/* =============================================================== */
kindOut = kindIn;
break;
/* Some other kinds are mapped to those above */
case nrrdKind3Color:
case nrrdKindRGBColor:
kindOut = nrrdKind3Vector;
break;
case nrrdKind4Color:
case nrrdKindRGBAColor:
kindOut = nrrdKind4Vector;
break;
default:
fprintf(stderr, "%s: got non-conforming kind %s on axis %u\n", me,
airEnumStr(nrrdKind, kindIn), kindAxis);
airMopError(mop);
exit(1);
break;
}
} else {
/* kindIn is nrrdKindUnknown, so its a simple scalar image,
and that's what the output will be too; kindOut == nrrdKindUnknown
is used in the code below to say "its a scalar image" */
kindOut = nrrdKindUnknown;
}
/* initialize output by copying */
nout = nrrdNew();
airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
if (nrrdCopy(nout, nin)) {
airMopAdd(mop, err = biffGet(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble copying:\n%s", me, err);
airMopError(mop);
exit(1);
}
/* no comments, either advertising the format URL or anything else */
nio = nrrdIoStateNew();
airMopAdd(mop, nio, (airMopper)nrrdIoStateNix, airMopAlways);
nio->skipFormatURL = AIR_TRUE;
if (headerOnly) {
nio->skipData = AIR_TRUE;
}
nrrdCommentClear(nout);
/* no measurement frame */
gotmf = AIR_FALSE;
for (si=0; si<NRRD_SPACE_DIM_MAX; si++) {
for (sj=0; sj<NRRD_SPACE_DIM_MAX; sj++) {
gotmf |= AIR_EXISTS(nout->measurementFrame[si][sj]);
}
}
if (gotmf) {
fprintf(stderr, "%s: WARNING: incoming array measurement frame; "
"it will be erased on output.\n", me);
/* airMopError(mop); exit(1); */
}
for (si=0; si<NRRD_SPACE_DIM_MAX; si++) {
for (sj=0; sj<NRRD_SPACE_DIM_MAX; sj++) {
nout->measurementFrame[si][sj] = AIR_NAN;
}
}
/* no key/value pairs */
nrrdKeyValueClear(nout);
/* no content field */
nout->content = airFree(nout->content);
/* normalize domain kinds to "space" */
/* turn off centers (Diderot assumes cell-centered, but that could
probably stand to be tested and enforced more) */
/* turn off thickness */
/* turn off labels and units */
for (axi=0; axi<nout->dim; axi++) {
if (nrrdKindUnknown == kindOut) {
nout->axis[axi].kind = nrrdKindSpace;
} else {
nout->axis[axi].kind = (kindAxis == axi
? kindOut
: nrrdKindSpace);
}
nout->axis[axi].center = nrrdCenterUnknown;
nout->axis[axi].thickness = AIR_NAN;
nout->axis[axi].label = airFree(nout->axis[axi].label);
nout->axis[axi].units = airFree(nout->axis[axi].units);
nout->axis[axi].min = AIR_NAN;
nout->axis[axi].max = AIR_NAN;
nout->axis[axi].spacing = AIR_NAN;
}
/* logic of orientation definition:
If space dimension is known:
set origin to zero if not already set
set space direction to unit vector if not already set
Else if have per-axis min and max:
set spae origin and directions to communicate same intent
as original per-axis min and max and original centering
Else
set origin to zero and all space directions to units.
It might be nice to use gage's logic for mapping from world to index,
but we have to accept a greater variety of kinds and dimensions
than gage ever has to process.
*/
if (nout->spaceDim && !trivialOrient) {
int saxi = 0;
/* we use only the space dimension, not any named space */
nout->space = nrrdSpaceUnknown;
if (!nrrdSpaceVecExists(nout->spaceDim, nout->spaceOrigin)) {
nrrdSpaceVecSetZero(nout->spaceOrigin);
}
for (axi=0; axi<nout->dim; axi++) {
if (nrrdKindUnknown == kindOut || kindAxis != axi) {
/* its a domain axis of output */
if (!nrrdSpaceVecExists(nout->spaceDim,
nout->axis[axi].spaceDirection)) {
nrrdSpaceVecSetZero(nout->axis[axi].spaceDirection);
nout->axis[axi].spaceDirection[saxi] = sscl;
}
/* else we leave existing space vector as is */
saxi++;
} else {
/* else its a range axis */
nrrdSpaceVecSetNaN(nout->axis[axi].spaceDirection);
}
}
} else if (haveMM && !trivialOrient) {
int saxi = 0;
size_t N;
double rng;
for (axi=0; axi<nout->dim; axi++) {
if (nrrdKindUnknown == kindOut || kindAxis != axi) {
/* its a domain axis of output */
nrrdSpaceVecSetZero(nout->axis[axi].spaceDirection);
rng = nin->axis[axi].max - nin->axis[axi].min;
if (nrrdCenterNode == nin->axis[axi].center) {
nout->spaceOrigin[saxi] = nin->axis[axi].min;
N = nin->axis[axi].size;
nout->axis[axi].spaceDirection[saxi] = rng/(N-1);
} else {
/* unknown centering treated as cell */
N = nin->axis[axi].size;
nout->spaceOrigin[saxi] = nin->axis[axi].min + (rng/N)/2;
nout->axis[axi].spaceDirection[saxi] = rng/N;
}
saxi++;
} else {
/* else its a range axis */
nrrdSpaceVecSetNaN(nout->axis[axi].spaceDirection);
}
}
nout->spaceDim = saxi;
} else {
/* either trivialOrient, or, not spaceDim and not haveMM */
int saxi = 0;
nout->space = nrrdSpaceUnknown;
nrrdSpaceVecSetZero(nout->spaceOrigin);
for (axi=0; axi<nout->dim; axi++) {
if (nrrdKindUnknown == kindOut || kindAxis != axi) {
/* its a domain axis of output */
nrrdSpaceVecSetZero(nout->axis[axi].spaceDirection);
nout->axis[axi].spaceDirection[saxi]
= (AIR_EXISTS(nin->axis[axi].spacing)
? nin->axis[axi].spacing
: sscl);
saxi++;
} else {
/* else its a range axis */
nrrdSpaceVecSetNaN(nout->axis[axi].spaceDirection);
}
}
nout->spaceDim = saxi;
}
/* space dimension has to match the number of domain axes */
if (nout->dim != nout->spaceDim + !!kindOut) {
fprintf(stderr, "%s: output dim %d != spaceDim %d + %d %s%s%s\n",
me, nout->dim, nout->spaceDim, !!kindOut,
kindOut ? "for non-scalar (" : "(scalar data)",
kindOut ? airEnumStr(nrrdKind, kindOut) : "",
kindOut ? ") data" : "");
airMopError(mop);
exit(1);
}
if (recenter) {
/* sets field's origin so field is centered on the origin. capiche? */
/* this code was tacked on later than the stuff above, so its
logic could probably be moved up there, but it seems cleaner to
have it as a separate post-process */
double mean[NRRD_SPACE_DIM_MAX];
nrrdSpaceVecSetZero(mean);
for (axi=0; axi<nout->dim; axi++) {
if (nrrdKindUnknown == kindOut || kindAxis != axi) {
nrrdSpaceVecScaleAdd2(mean, 1.0, mean,
0.5*(nout->axis[axi].size - 1),
nout->axis[axi].spaceDirection);
}
}
nrrdSpaceVecScaleAdd2(mean, 1.0, mean,
1.0, nout->spaceOrigin);
/* now mean is the center of the field */
nrrdSpaceVecScaleAdd2(nout->spaceOrigin,
1.0, nout->spaceOrigin,
-1.0, mean);
}
if (nrrdSave(outS, nout, nio)) {
airMopAdd(mop, err = biffGet(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble saving \"%s\":\n%s",
me, outS, err);
airMopError(mop);
exit(1);
}
airMopOkay(mop);
return 0;
}
