/*
******** nrrdNew()
**
** creates and initializes a Nrrd
**
** this does NOT use biff
*/
Nrrd *
nrrdNew(void)
{
int ii;
Nrrd *nrrd;
nrrd = (Nrrd*)(calloc(1, sizeof(Nrrd)));
if (!nrrd)
{
return NULL;
}
/* explicitly set pointers to NULL, since calloc isn't officially
guaranteed to do that. */
nrrd->data = NULL;
for (ii=0; ii<NRRD_DIM_MAX; ii++)
{
_nrrdAxisInfoNewInit(nrrd->axis + ii);
}
for (ii=0; ii<NRRD_SPACE_DIM_MAX; ii++)
{
nrrd->spaceUnits[ii] = NULL;
}
nrrd->content = NULL;
nrrd->sampleUnits = NULL;
/* create comment airArray (even though it starts empty) */
nrrd->cmt = NULL;
void *pvoid = (void*)&(nrrd->cmt);
nrrd->cmtArr = airArrayNew((void**)pvoid, NULL,
sizeof(char *), NRRD_COMMENT_INCR);
if (!nrrd->cmtArr)
{
return NULL;
}
airArrayPointerCB(nrrd->cmtArr, airNull, airFree);
/* create key/value airArray (even thought it starts empty) */
nrrd->kvp = NULL;
pvoid = &(nrrd->kvp);
nrrd->kvpArr = airArrayNew((void**)pvoid, NULL,
2*sizeof(char *), NRRD_KEYVALUE_INCR);
if (!nrrd->kvpArr)
{
return NULL;
}
/* key/value airArray uses no callbacks for now */
/* finish initializations */
nrrdInit(nrrd);
return nrrd;
}
/*
******** 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;
}
