/*
******** nrrdNix()
**
** does nothing with the array data inside, just does whatever is needed
** to free the nrrd itself
**
** returns NULL
**
** this does NOT use biff
*/
Nrrd *
nrrdNix(Nrrd *nrrd)
{
int ii;
if (nrrd)
{
for (ii=0; ii<NRRD_DIM_MAX; ii++)
{
_nrrdAxisInfoInit(&(nrrd->axis[ii]));
}
for (ii=0; ii<NRRD_SPACE_DIM_MAX; ii++)
{
nrrd->spaceUnits[ii] = (char *)airFree(nrrd->spaceUnits[ii]);
}
nrrd->content = (char *)airFree(nrrd->content);
nrrd->sampleUnits = (char *)airFree(nrrd->sampleUnits);
nrrdCommentClear(nrrd);
nrrd->cmtArr = airArrayNix(nrrd->cmtArr);
nrrdKeyValueClear(nrrd);
nrrd->kvpArr = airArrayNix(nrrd->kvpArr);
airFree(nrrd);
}
return NULL;
}
void
_nrrdAxisInfoNewInit(NrrdAxisInfo *axis) {
if (axis) {
axis->label = NULL;
axis->units = NULL;
_nrrdAxisInfoInit(axis);
}
}
/*
******* nrrdInit
**
** initializes a nrrd to default state. All nrrd functions in the
** business of initializing a nrrd struct use this function. Mostly
** just sets values to 0, NaN, "", NULL, or Unknown
*/
void
nrrdInit(Nrrd *nrrd) {
int ii;
if (nrrd) {
nrrdBasicInfoInit(nrrd, NRRD_BASIC_INFO_NONE);
for (ii=0; ii<NRRD_DIM_MAX; ii++) {
_nrrdAxisInfoInit(nrrd->axis + ii);
}
}
return;
}
/*
******** nrrdAxesInsert
**
** like reshape, but preserves axis information on old axes, and
** this is only for adding a "stub" axis with length 1. All other
** axis attributes are initialized as usual.
*/
int
nrrdAxesInsert(Nrrd *nout, const Nrrd *nin, unsigned int axis) {
static const char me[]="nrrdAxesInsert", func[]="axinsert";
unsigned int ai;
if (!(nout && nin)) {
biffAddf(NRRD, "%s: got NULL pointer", me);
return 1;
}
if (!( axis <= nin->dim )) {
biffAddf(NRRD, "%s: given axis (%d) outside valid range [0, %d]",
me, axis, nin->dim);
return 1;
}
if (NRRD_DIM_MAX == nin->dim) {
biffAddf(NRRD, "%s: given nrrd already at NRRD_DIM_MAX (%d)",
me, NRRD_DIM_MAX);
return 1;
}
if (nout != nin) {
if (_nrrdCopy(nout, nin, (NRRD_BASIC_INFO_COMMENTS_BIT
| (nrrdStateKeyValuePairsPropagate
? 0
: NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT)))) {
biffAddf(NRRD, "%s:", me);
return 1;
}
}
nout->dim = 1 + nin->dim;
for (ai=nin->dim; ai>axis; ai--) {
_nrrdAxisInfoCopy(&(nout->axis[ai]), &(nin->axis[ai-1]),
NRRD_AXIS_INFO_NONE);
}
/* the ONLY thing we can say about the new axis is its size */
_nrrdAxisInfoInit(&(nout->axis[axis]));
if (!nrrdStateKindNoop) {
/* except maybe the kind */
nout->axis[axis].kind = nrrdKindStub;
}
nout->axis[axis].size = 1;
if (nrrdContentSet_va(nout, func, nin, "%d", axis)) {
biffAddf(NRRD, "%s:", me);
return 1;
}
/* all basic info has already been copied by nrrdCopy() above */
return 0;
}
/*
******** nrrdAxisInfoCopy()
**
** For copying all the per-axis peripheral information. Takes a
** permutation "map"; map[d] tells from which axis in input should the
** output axis d copy its information. The length of this permutation
** array is nout->dim. If map is NULL, the identity permutation is
** assumed. If map[i]==-1 for any i in [0,dim-1], then nothing is
** copied into axis i of output. The "bitflag" field controls which
** per-axis fields will NOT be copied; if bitflag==0, then all fields
** are copied. The value of bitflag should be |'s of NRRD_AXIS_INFO_*
** defines.
**
** Decided to Not use Biff, since many times map will be NULL, in
** which case the only error is getting a NULL nrrd, or an invalid map
** permutation, which will probably be unlikely given the contexts in
** which this is called. For the paranoid, the integer return value
** indicates error.
**
** Sun Feb 27 21:12:57 EST 2005: decided to allow nout==nin, so now
** use a local array of NrrdAxisInfo as buffer.
*/
int
nrrdAxisInfoCopy(Nrrd *nout, const Nrrd *nin, const int *axmap, int bitflag) {
NrrdAxisInfo axisBuffer[NRRD_DIM_MAX];
const NrrdAxisInfo *axis;
unsigned int from, axi;
if (!(nout && nin)) {
return 1;
}
if (axmap) {
for (axi=0; axi<nout->dim; axi++) {
if (-1 == axmap[axi]) {
continue;
}
if (!AIR_IN_CL(0, axmap[axi], (int)nin->dim-1)) {
return 3;
}
}
}
if (nout == nin) {
/* copy axis info to local buffer */
for (axi=0; axi<nin->dim; axi++) {
_nrrdAxisInfoNewInit(axisBuffer + axi);
_nrrdAxisInfoCopy(axisBuffer + axi, nin->axis + axi, bitflag);
}
axis = axisBuffer;
} else {
axis = nin->axis;
}
for (axi=0; axi<nout->dim; axi++) {
if (axmap && -1 == axmap[axi]) {
/* for this axis, we don't touch a thing */
continue;
}
from = axmap ? (unsigned int)axmap[axi] : axi;
_nrrdAxisInfoCopy(nout->axis + axi, axis + from, bitflag);
}
if (nout == nin) {
/* free dynamically allocated stuff */
for (axi=0; axi<nin->dim; axi++) {
_nrrdAxisInfoInit(axisBuffer + axi);
}
}
return 0;
}
