/*
******** nrrdInset()
**
** (opposite of nrrdCrop()) replace some sub-volume inside a nrrd with
** another given nrrd.
**
*/
int
nrrdInset(Nrrd *nout, const Nrrd *nin, const Nrrd *nsub, const size_t *min) {
char me[]="nrrdInset", func[] = "inset", err[BIFF_STRLEN],
buff1[NRRD_DIM_MAX*30], buff2[AIR_STRLEN_SMALL];
unsigned int ai;
size_t I,
lineSize, /* #bytes in one scanline to be copied */
typeSize, /* size of data type */
cIn[NRRD_DIM_MAX], /* coords for line start, in input */
cOut[NRRD_DIM_MAX], /* coords for line start, in output */
szIn[NRRD_DIM_MAX],
szOut[NRRD_DIM_MAX],
idxIn, idxOut, /* linear indices for input and output */
numLines; /* number of scanlines in output nrrd */
char *dataIn, *dataOut, *subCont;
/* errors */
if (!(nout && nin && nsub && min)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(NRRD, err); return 1;
}
if (nout == nsub) {
sprintf(err, "%s: nout==nsub disallowed", me);
biffAdd(NRRD, err); return 1;
}
if (nrrdCheck(nin)) {
sprintf(err, "%s: input not valid nrrd", me);
biffAdd(NRRD, err); return 1;
}
if (nrrdCheck(nsub)) {
sprintf(err, "%s: subvolume not valid nrrd", me);
biffAdd(NRRD, err); return 1;
}
if (!( nin->dim == nsub->dim )) {
sprintf(err, "%s: input's dim (%d) != subvolume's dim (%d)",
me, nin->dim, nsub->dim);
biffAdd(NRRD, err); return 1;
}
if (!( nin->type == nsub->type )) {
sprintf(err, "%s: input's type (%s) != subvolume's type (%s)", me,
airEnumStr(nrrdType, nin->type),
airEnumStr(nrrdType, nsub->type));
biffAdd(NRRD, err); return 1;
}
if (nrrdTypeBlock == nin->type) {
if (!( nin->blockSize == nsub->blockSize )) {
sprintf(err, "%s: input's blockSize (" _AIR_SIZE_T_CNV
") != subvolume's blockSize (" _AIR_SIZE_T_CNV ")",
me, nin->blockSize, nsub->blockSize);
biffAdd(NRRD, err); return 1;
}
}
for (ai=0; ai<nin->dim; ai++) {
if (!( min[ai] + nsub->axis[ai].size - 1 <= nin->axis[ai].size - 1)) {
sprintf(err, "%s: axis %d range of inset indices [" _AIR_SIZE_T_CNV
"," _AIR_SIZE_T_CNV "] not within "
"input indices [0," _AIR_SIZE_T_CNV "]", me, ai,
min[ai], min[ai] + nsub->axis[ai].size - 1,
nin->axis[ai].size - 1);
biffAdd(NRRD, err); return 1;
}
}
if (nout != nin) {
if (nrrdCopy(nout, nin)) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); return 1;
}
}
/* else we're going to inset in place */
/* WARNING: following code copied/modified from nrrdCrop(),
so the meanings of "in"/"out", "src"/"dest" are all messed up */
nrrdAxisInfoGet_nva(nin, nrrdAxisInfoSize, szIn);
nrrdAxisInfoGet_nva(nsub, nrrdAxisInfoSize, szOut);
numLines = 1;
for (ai=1; ai<nin->dim; ai++) {
numLines *= szOut[ai];
}
lineSize = szOut[0]*nrrdElementSize(nin);
/* the skinny */
typeSize = nrrdElementSize(nin);
dataIn = (char *)nout->data;
dataOut = (char *)nsub->data;
for (ai=0; ai<NRRD_DIM_MAX; ai++) {
cOut[ai] = 0;
}
for (I=0; I<numLines; I++) {
for (ai=0; ai<nin->dim; ai++) {
cIn[ai] = cOut[ai] + min[ai];
}
NRRD_INDEX_GEN(idxOut, cOut, szOut, nin->dim);
NRRD_INDEX_GEN(idxIn, cIn, szIn, nin->dim);
memcpy(dataIn + idxIn*typeSize, dataOut + idxOut*typeSize, lineSize);
/* the lowest coordinate in cOut[] will stay zero, since we are
copying one (1-D) scanline at a time */
NRRD_COORD_INCR(cOut, szOut, nin->dim, 1);
}
/* HEY: before Teem version 2.0 figure out nrrdKind stuff here */
strcpy(buff1, "[");
for (ai=0; ai<nin->dim; ai++) {
sprintf(buff2, "%s" _AIR_SIZE_T_CNV, (ai ? "," : ""), min[ai]);
strcat(buff1, buff2);
}
strcat(buff1, "]");
subCont = _nrrdContentGet(nsub);
if (nrrdContentSet_va(nout, func, nin, "%s,%s", subCont, buff1)) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); free(subCont); return 1;
}
free(subCont);
/* basic info copied by nrrdCopy above */
return 0;
}
/*
******** nrrdCrop()
**
** select some sub-volume inside a given nrrd, producing an output
** nrrd with the same dimensions, but with equal or smaller sizes
** along each axis.
*/
int
nrrdCrop(Nrrd *nout, const Nrrd *nin, size_t *min, size_t *max)
{
char me[]="nrrdCrop", func[] = "crop", err[BIFF_STRLEN],
buff1[NRRD_DIM_MAX*30], buff2[AIR_STRLEN_SMALL];
unsigned int ai;
size_t I,
lineSize, /* #bytes in one scanline to be copied */
typeSize, /* size of data type */
cIn[NRRD_DIM_MAX], /* coords for line start, in input */
cOut[NRRD_DIM_MAX], /* coords for line start, in output */
szIn[NRRD_DIM_MAX],
szOut[NRRD_DIM_MAX],
idxIn=0, idxOut=0, /* linear indices for input and output */
numLines; /* number of scanlines in output nrrd */
char *dataIn, *dataOut;
/* errors */
if (!(nout && nin && min && max))
{
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;
}
for (ai=0; ai<nin->dim; ai++)
{
if (!(min[ai] <= max[ai]))
{
sprintf(err, "%s: axis %d min (" _AIR_SIZE_T_CNV
") not <= max (" _AIR_SIZE_T_CNV ")",
me, ai, min[ai], max[ai]);
biffAdd(NRRD, err);
return 1;
}
if (!( min[ai] < nin->axis[ai].size && max[ai] < nin->axis[ai].size ))
{
sprintf(err, "%s: axis %d min (" _AIR_SIZE_T_CNV
") or max (" _AIR_SIZE_T_CNV ") out of bounds [0,"
_AIR_SIZE_T_CNV "]",
me, ai, min[ai], max[ai], nin->axis[ai].size-1);
biffAdd(NRRD, err);
return 1;
}
}
/* this shouldn't actually be necessary .. */
if (!nrrdElementSize(nin))
{
sprintf(err, "%s: nrrd reports zero element size!", me);
biffAdd(NRRD, err);
return 1;
}
/* allocate */
nrrdAxisInfoGet_nva(nin, nrrdAxisInfoSize, szIn);
numLines = 1;
for (ai=0; ai<nin->dim; ai++)
{
szOut[ai] = max[ai] - min[ai] + 1;
if (ai)
{
numLines *= szOut[ai];
}
}
nout->blockSize = nin->blockSize;
if (nrrdMaybeAlloc_nva(nout, nin->type, nin->dim, szOut))
{
sprintf(err, "%s:", me);
biffAdd(NRRD, err);
return 1;
}
lineSize = szOut[0]*nrrdElementSize(nin);
/* the skinny */
typeSize = nrrdElementSize(nin);
dataIn = (char *)nin->data;
dataOut = (char *)nout->data;
memset(cOut, 0, NRRD_DIM_MAX*sizeof(unsigned int));
/*
printf("!%s: nin->dim = %d\n", me, nin->dim);
printf("!%s: min = %d %d %d\n", me, min[0], min[1], min[2]);
printf("!%s: szIn = %d %d %d\n", me, szIn[0], szIn[1], szIn[2]);
printf("!%s: szOut = %d %d %d\n", me, szOut[0], szOut[1], szOut[2]);
printf("!%s: lineSize = %d\n", me, lineSize);
printf("!%s: typeSize = %d\n", me, typeSize);
printf("!%s: numLines = %d\n", me, (int)numLines);
*/
for (I=0; I<numLines; I++)
{
for (ai=0; ai<nin->dim; ai++)
{
cIn[ai] = cOut[ai] + min[ai];
}
NRRD_INDEX_GEN(idxOut, cOut, szOut, nin->dim);
NRRD_INDEX_GEN(idxIn, cIn, szIn, nin->dim);
/*
printf("!%s: %5d: cOut=(%3d,%3d,%3d) --> idxOut = %5d\n",
me, (int)I, cOut[0], cOut[1], cOut[2], (int)idxOut);
printf("!%s: %5d: cIn=(%3d,%3d,%3d) --> idxIn = %5d\n",
me, (int)I, cIn[0], cIn[1], cIn[2], (int)idxIn);
*/
memmove(dataOut + idxOut*typeSize, dataIn + idxIn*typeSize, lineSize);
/* the lowest coordinate in cOut[] will stay zero, since we are
copying one (1-D) scanline at a time */
NRRD_COORD_INCR(cOut, szOut, nin->dim, 1);
}
if (nrrdAxisInfoCopy(nout, nin, NULL, (NRRD_AXIS_INFO_SIZE_BIT |
NRRD_AXIS_INFO_MIN_BIT |
NRRD_AXIS_INFO_MAX_BIT )))
{
sprintf(err, "%s:", me);
biffAdd(NRRD, err);
return 1;
}
for (ai=0; ai<nin->dim; ai++)
{
nrrdAxisInfoPosRange(&(nout->axis[ai].min), &(nout->axis[ai].max),
nin, ai, min[ai], max[ai]);
/* do the safe thing first */
nout->axis[ai].kind = _nrrdKindAltered(nin->axis[ai].kind, AIR_FALSE);
/* try cleverness */
if (!nrrdStateKindNoop)
{
if (nout->axis[ai].size == nin->axis[ai].size)
{
/* we can safely copy kind; the samples didn't change */
nout->axis[ai].kind = nin->axis[ai].kind;
}
else if (nrrdKind4Color == nin->axis[ai].kind
&& 3 == szOut[ai])
{
nout->axis[ai].kind = nrrdKind3Color;
}
else if (nrrdKind4Vector == nin->axis[ai].kind
&& 3 == szOut[ai])
{
nout->axis[ai].kind = nrrdKind3Vector;
}
else if ((nrrdKind4Vector == nin->axis[ai].kind
|| nrrdKind3Vector == nin->axis[ai].kind)
&& 2 == szOut[ai])
{
nout->axis[ai].kind = nrrdKind2Vector;
}
else if (nrrdKindRGBAColor == nin->axis[ai].kind
&& 0 == min[ai]
&& 2 == max[ai])
{
nout->axis[ai].kind = nrrdKindRGBColor;
}
else if (nrrdKind2DMaskedSymMatrix == nin->axis[ai].kind
&& 1 == min[ai]
&& max[ai] == szIn[ai]-1)
{
nout->axis[ai].kind = nrrdKind2DSymMatrix;
}
else if (nrrdKind2DMaskedMatrix == nin->axis[ai].kind
&& 1 == min[ai]
&& max[ai] == szIn[ai]-1)
{
nout->axis[ai].kind = nrrdKind2DMatrix;
}
else if (nrrdKind3DMaskedSymMatrix == nin->axis[ai].kind
&& 1 == min[ai]
&& max[ai] == szIn[ai]-1)
{
nout->axis[ai].kind = nrrdKind3DSymMatrix;
}
else if (nrrdKind3DMaskedMatrix == nin->axis[ai].kind
&& 1 == min[ai]
&& max[ai] == szIn[ai]-1)
{
nout->axis[ai].kind = nrrdKind3DMatrix;
}
}
}
strcpy(buff1, "");
for (ai=0; ai<nin->dim; ai++)
{
sprintf(buff2, "%s[" _AIR_SIZE_T_CNV "," _AIR_SIZE_T_CNV "]",
(ai ? "x" : ""), min[ai], max[ai]);
strcat(buff1, buff2);
}
if (nrrdContentSet_va(nout, func, nin, "%s", buff1))
{
sprintf(err, "%s:", me);
biffAdd(NRRD, err);
return 1;
}
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_SPACEORIGIN_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);
return 1;
}
/* copy origin, then shift it along the spatial axes */
_nrrdSpaceVecCopy(nout->spaceOrigin, nin->spaceOrigin);
for (ai=0; ai<nin->dim; ai++)
{
if (AIR_EXISTS(nin->axis[ai].spaceDirection[0]))
{
_nrrdSpaceVecScaleAdd2(nout->spaceOrigin,
1.0, nout->spaceOrigin,
min[ai], nin->axis[ai].spaceDirection);
}
}
return 0;
}
/*
******** nrrdShuffle
**
** rearranges hyperslices of a nrrd along a given axis according to
** given permutation. This could be used to on a 4D array,
** representing a 3D volume of vectors, to re-order the vector
** components.
**
** the given permutation array must allocated for at least as long as
** the input nrrd along the chosen axis. perm[j] = i means that the
** value at position j in the _new_ array should come from position i
** in the _old_array. The standpoint is from the new, looking at
** where to find the values amid the old array (perm answers "what do
** I put here", not "where do I put this"). This allows multiple
** positions in the new array to copy from the same old position, and
** insures that there is an source for all positions along the new
** array.
*/
int
nrrdShuffle(Nrrd *nout, const Nrrd *nin, unsigned int axis,
const size_t *perm) {
static const char me[]="nrrdShuffle", func[]="shuffle";
char buff2[AIR_STRLEN_SMALL];
/* Sun Feb 8 13:13:58 CST 2009: There was a memory bug here caused
by using the same buff1[NRRD_DIM_MAX*30] declaration that had
worked fine for nrrdAxesPermute and nrrdReshape, but does NOT
work here because now samples along an axes are re-ordered, not
axes, so its often not allocated for long enough to hold the
string that's printed to it. Ideally there'd be another argument
that says whether to document the shuffle in the content string,
which would mean an API change. Or, we can use a secret
heuristic (or maybe later a nrrdState variable) for determining
when an axis is short enough to make documenting the shuffle
interesting. This is useful since functions like nrrdFlip()
probably do *not* need the shuffle (the sample reversal) to be
documented for long axes */
#define LONGEST_INTERESTING_AXIS 42
char buff1[LONGEST_INTERESTING_AXIS*30];
unsigned int ai, ldim, len;
size_t idxInB=0, idxOut, lineSize, numLines, size[NRRD_DIM_MAX], *lsize,
cIn[NRRD_DIM_MAX+1], cOut[NRRD_DIM_MAX+1];
char *dataIn, *dataOut;
if (!(nin && nout && perm)) {
biffAddf(NRRD, "%s: got NULL pointer", me);
return 1;
}
if (nout == nin) {
biffAddf(NRRD, "%s: nout==nin disallowed", me);
return 1;
}
if (!( axis < nin->dim )) {
biffAddf(NRRD, "%s: axis %d outside valid range [0,%d]",
me, axis, nin->dim-1);
return 1;
}
len = AIR_CAST(unsigned int, nin->axis[axis].size);
for (ai=0; ai<len; ai++) {
if (!( perm[ai] < len )) {
char stmp[AIR_STRLEN_SMALL];
biffAddf(NRRD, "%s: perm[%d] (%s) outside valid range [0,%d]", me, ai,
airSprintSize_t(stmp, perm[ai]), len-1);
return 1;
}
}
/* this shouldn't actually be necessary .. */
if (!nrrdElementSize(nin)) {
biffAddf(NRRD, "%s: nrrd reports zero element size!", me);
return 1;
}
/* set information in new volume */
nout->blockSize = nin->blockSize;
nrrdAxisInfoGet_nva(nin, nrrdAxisInfoSize, size);
if (nrrdMaybeAlloc_nva(nout, nin->type, nin->dim, size)) {
biffAddf(NRRD, "%s: failed to allocate output", me);
return 1;
}
if (nrrdAxisInfoCopy(nout, nin, NULL, NRRD_AXIS_INFO_NONE)) {
biffAddf(NRRD, "%s:", me);
return 1;
}
/* the min and max along the shuffled axis are now meaningless */
nout->axis[axis].min = nout->axis[axis].max = AIR_NAN;
/* do the safe thing first */
nout->axis[axis].kind = _nrrdKindAltered(nin->axis[axis].kind, AIR_FALSE);
/* try cleverness */
if (!nrrdStateKindNoop) {
if (0 == nrrdKindSize(nin->axis[axis].kind)
|| nrrdKindStub == nin->axis[axis].kind
|| nrrdKindScalar == nin->axis[axis].kind
|| nrrdKind2Vector == nin->axis[axis].kind
|| nrrdKind3Color == nin->axis[axis].kind
|| nrrdKind4Color == nin->axis[axis].kind
|| nrrdKind3Vector == nin->axis[axis].kind
|| nrrdKind3Gradient == nin->axis[axis].kind
|| nrrdKind3Normal == nin->axis[axis].kind
|| nrrdKind4Vector == nin->axis[axis].kind) {
/* these kinds have no intrinsic ordering */
nout->axis[axis].kind = nin->axis[axis].kind;
}
}
/* the skinny */
lineSize = 1;
for (ai=0; ai<axis; ai++) {
lineSize *= nin->axis[ai].size;
}
numLines = nrrdElementNumber(nin)/lineSize;
lineSize *= nrrdElementSize(nin);
lsize = size + axis;
ldim = nin->dim - axis;
dataIn = AIR_CAST(char *, nin->data);
dataOut = AIR_CAST(char *, nout->data);
memset(cIn, 0, sizeof(cIn));
memset(cOut, 0, sizeof(cOut));
for (idxOut=0; idxOut<numLines; idxOut++) {
memcpy(cIn, cOut, sizeof(cIn));
cIn[0] = perm[cOut[0]];
NRRD_INDEX_GEN(idxInB, cIn, lsize, ldim);
NRRD_INDEX_GEN(idxOut, cOut, lsize, ldim);
memcpy(dataOut + idxOut*lineSize, dataIn + idxInB*lineSize, lineSize);
NRRD_COORD_INCR(cOut, lsize, ldim, 0);
}
/* Set content. The LONGEST_INTERESTING_AXIS hack avoids the
previous array out-of-bounds bug */
if (len <= LONGEST_INTERESTING_AXIS) {
strcpy(buff1, "");
for (ai=0; ai<len; ai++) {
char stmp[AIR_STRLEN_SMALL];
sprintf(buff2, "%s%s", (ai ? "," : ""), airSprintSize_t(stmp, perm[ai]));
strcat(buff1, buff2);
}
if (nrrdContentSet_va(nout, func, nin, "%s", buff1)) {
biffAddf(NRRD, "%s:", me);
return 1;
}
} else {
if (nrrdContentSet_va(nout, func, nin, "")) {
biffAddf(NRRD, "%s:", me);
return 1;
}
}
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))) {
biffAddf(NRRD, "%s:", me);
return 1;
}
return 0;
#undef LONGEST_INTERESTING_AXIS
}
/*
******** nrrdHistoAxis
**
** replace scanlines along one scanline with a histogram of the scanline
**
** this looks at nin->min and nin->max to see if they are both non-NaN.
** If so, it uses these as the range of the histogram, otherwise it
** finds the min and max present in the volume
**
** By its very nature, and by the simplicity of this implemention,
** this can be a slow process due to terrible memory locality. User
** may want to permute axes before and after this, but that can be
** slow too...
*/
int
nrrdHistoAxis(Nrrd *nout, const Nrrd *nin, const NrrdRange *_range,
unsigned int hax, size_t bins, int type) {
static const char me[]="nrrdHistoAxis", func[]="histax";
int map[NRRD_DIM_MAX];
unsigned int ai, hidx;
size_t szIn[NRRD_DIM_MAX], szOut[NRRD_DIM_MAX], size[NRRD_DIM_MAX],
coordIn[NRRD_DIM_MAX], coordOut[NRRD_DIM_MAX];
size_t I, hI, num;
double val, count;
airArray *mop;
NrrdRange *range;
if (!(nin && nout)) {
biffAddf(NRRD, "%s: got NULL pointer", me);
return 1;
}
if (nout == nin) {
biffAddf(NRRD, "%s: nout==nin disallowed", me);
return 1;
}
if (!(bins > 0)) {
biffAddf(NRRD, "%s: bins value (" _AIR_SIZE_T_CNV ") invalid", me, bins);
return 1;
}
if (airEnumValCheck(nrrdType, type) || nrrdTypeBlock == type) {
biffAddf(NRRD, "%s: invalid nrrd type %d", me, type);
return 1;
}
if (!( hax <= nin->dim-1 )) {
biffAddf(NRRD, "%s: axis %d is not in range [0,%d]",
me, hax, nin->dim-1);
return 1;
}
mop = airMopNew();
if (_range) {
range = nrrdRangeCopy(_range);
nrrdRangeSafeSet(range, nin, nrrdBlind8BitRangeState);
} else {
range = nrrdRangeNewSet(nin, nrrdBlind8BitRangeState);
}
airMopAdd(mop, range, (airMopper)nrrdRangeNix, airMopAlways);
nrrdAxisInfoGet_nva(nin, nrrdAxisInfoSize, size);
size[hax] = bins;
if (nrrdMaybeAlloc_nva(nout, type, nin->dim, size)) {
biffAddf(NRRD, "%s: failed to alloc output nrrd", me);
airMopError(mop); return 1;
}
/* copy axis information */
for (ai=0; ai<nin->dim; ai++) {
map[ai] = ai != hax ? (int)ai : -1;
}
nrrdAxisInfoCopy(nout, nin, map, NRRD_AXIS_INFO_NONE);
/* axis hax now has to be set manually */
nout->axis[hax].size = bins;
nout->axis[hax].spacing = AIR_NAN; /* min and max convey the information */
nout->axis[hax].thickness = AIR_NAN;
nout->axis[hax].min = range->min;
nout->axis[hax].max = range->max;
nout->axis[hax].center = nrrdCenterCell;
if (nin->axis[hax].label) {
nout->axis[hax].label = (char *)calloc(strlen("histax()")
+ strlen(nin->axis[hax].label)
+ 1, sizeof(char));
if (nout->axis[hax].label) {
sprintf(nout->axis[hax].label, "histax(%s)", nin->axis[hax].label);
} else {
biffAddf(NRRD, "%s: couldn't allocate output label", me);
airMopError(mop); return 1;
}
} else {
nout->axis[hax].label = NULL;
}
if (!nrrdStateKindNoop) {
nout->axis[hax].kind = nrrdKindDomain;
}
/* the skinny: we traverse the input samples in linear order, and
increment the bin in the histogram for the scanline we're in.
This is not terribly clever, and the memory locality is a
disaster */
nrrdAxisInfoGet_nva(nin, nrrdAxisInfoSize, szIn);
nrrdAxisInfoGet_nva(nout, nrrdAxisInfoSize, szOut);
memset(coordIn, 0, NRRD_DIM_MAX*sizeof(size_t));
num = nrrdElementNumber(nin);
for (I=0; I<num; I++) {
/* get input nrrd value and compute its histogram index */
val = nrrdDLookup[nin->type](nin->data, I);
if (AIR_EXISTS(val) && AIR_IN_CL(range->min, val, range->max)) {
hidx = airIndex(range->min, val, range->max, AIR_CAST(unsigned int, bins));
memcpy(coordOut, coordIn, nin->dim*sizeof(size_t));
coordOut[hax] = (unsigned int)hidx;
NRRD_INDEX_GEN(hI, coordOut, szOut, nout->dim);
count = nrrdDLookup[nout->type](nout->data, hI);
count = nrrdDClamp[nout->type](count + 1);
nrrdDInsert[nout->type](nout->data, hI, count);
}
NRRD_COORD_INCR(coordIn, szIn, nin->dim, 0);
}
/*
******** nrrdAxesPermute
**
** changes the scanline ordering of the data in a nrrd
**
** The basic means by which data is moved around is with memcpy().
** The goal is to call memcpy() as few times as possible, on memory
** segments as large as possible. Currently, this is done by
** detecting how many of the low-index axes are left untouched by
** the permutation- this constitutes a "scanline" which can be
** copied around as a unit. For permuting the y and z axes of a
** matrix-x-y-z order matrix volume, this optimization produced a
** factor of 5 speed up (exhaustive multi-platform tests, of course).
**
** The axes[] array determines the permutation of the axes.
** axis[i] = j means: axis i in the output will be the input's axis j
** (axis[i] answers: "what do I put here", from the standpoint of the output,
** not "where do I put this", from the standpoint of the input)
*/
int
nrrdAxesPermute(Nrrd *nout, const Nrrd *nin, const unsigned int *axes) {
static const char me[]="nrrdAxesPermute", func[]="permute";
char buff1[NRRD_DIM_MAX*30], buff2[AIR_STRLEN_SMALL];
size_t idxOut, idxInA=0, /* indices for input and output scanlines */
lineSize, /* size of block of memory which can be
moved contiguously from input to output,
thought of as a "scanline" */
numLines, /* how many "scanlines" there are to permute */
szIn[NRRD_DIM_MAX], *lszIn,
szOut[NRRD_DIM_MAX], *lszOut,
cIn[NRRD_DIM_MAX],
cOut[NRRD_DIM_MAX];
char *dataIn, *dataOut;
int axmap[NRRD_DIM_MAX];
unsigned int
ai, /* running index along dimensions */
lowPax, /* lowest axis which is "p"ermutated */
ldim, /* nin->dim - lowPax */
ip[NRRD_DIM_MAX+1], /* inverse of permutation in "axes" */
laxes[NRRD_DIM_MAX+1]; /* copy of axes[], but shifted down by lowPax
elements, to remove i such that i == axes[i] */
airArray *mop;
mop = airMopNew();
if (!(nin && nout && axes)) {
biffAddf(NRRD, "%s: got NULL pointer", me);
airMopError(mop); return 1;
}
/* we don't actually need ip[], computing it is for error checking */
if (nrrdInvertPerm(ip, axes, nin->dim)) {
biffAddf(NRRD, "%s: couldn't compute axis permutation inverse", me);
airMopError(mop); return 1;
}
/* this shouldn't actually be necessary .. */
if (!nrrdElementSize(nin)) {
biffAddf(NRRD, "%s: nrrd reports zero element size!", me);
airMopError(mop); return 1;
}
for (ai=0; ai<nin->dim && axes[ai] == ai; ai++)
;
lowPax = ai;
/* allocate output by initial copy */
if (nout != nin) {
if (nrrdCopy(nout, nin)) {
biffAddf(NRRD, "%s: trouble copying input", me);
airMopError(mop); return 1;
}
dataIn = (char*)nin->data;
} else {
dataIn = (char*)calloc(nrrdElementNumber(nin), nrrdElementSize(nin));
if (!dataIn) {
biffAddf(NRRD, "%s: couldn't create local copy of data", me);
airMopError(mop); return 1;
}
airMopAdd(mop, dataIn, airFree, airMopAlways);
memcpy(dataIn, nin->data, nrrdElementNumber(nin)*nrrdElementSize(nin));
}
if (lowPax < nin->dim) {
/* if lowPax == nin->dim, then we were given the identity permutation, so
there's nothing to do other than the copy already done. Otherwise,
here we are (actually, lowPax < nin->dim-1) */
for (ai=0; ai<nin->dim; ai++) {
axmap[ai] = AIR_INT(axes[ai]);
}
nrrdAxisInfoGet_nva(nin, nrrdAxisInfoSize, szIn);
if (nrrdAxisInfoCopy(nout, nin, axmap, NRRD_AXIS_INFO_NONE)) {
biffAddf(NRRD, "%s:", me);
airMopError(mop); return 1;
}
nrrdAxisInfoGet_nva(nout, nrrdAxisInfoSize, szOut);
/* the skinny */
lineSize = 1;
for (ai=0; ai<lowPax; ai++) {
lineSize *= szIn[ai];
}
numLines = nrrdElementNumber(nin)/lineSize;
lineSize *= nrrdElementSize(nin);
lszIn = szIn + lowPax;
lszOut = szOut + lowPax;
ldim = nin->dim - lowPax;
memset(laxes, 0, sizeof(laxes));
for (ai=0; ai<ldim; ai++) {
laxes[ai] = axes[ai+lowPax]-lowPax;
}
dataOut = AIR_CAST(char *, nout->data);
memset(cIn, 0, sizeof(cIn));
memset(cOut, 0, sizeof(cOut));
for (idxOut=0; idxOut<numLines; idxOut++) {
/* in our representation of the coordinates of the start of the
scanlines that we're copying, we are not even storing all the
zeros in the coordinates prior to lowPax, and when we go to
a linear index for the memcpy(), we multiply by lineSize */
for (ai=0; ai<ldim; ai++) {
cIn[laxes[ai]] = cOut[ai];
}
NRRD_INDEX_GEN(idxInA, cIn, lszIn, ldim);
memcpy(dataOut + idxOut*lineSize, dataIn + idxInA*lineSize, lineSize);
NRRD_COORD_INCR(cOut, lszOut, ldim, 0);
}
/* set content */
strcpy(buff1, "");
for (ai=0; ai<nin->dim; ai++) {
sprintf(buff2, "%s%d", (ai ? "," : ""), axes[ai]);
strcat(buff1, buff2);
}
if (nrrdContentSet_va(nout, func, nin, "%s", buff1)) {
biffAddf(NRRD, "%s:", me);
airMopError(mop); return 1;
}
if (nout != nin) {
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))) {
biffAddf(NRRD, "%s:", me);
airMopError(mop); return 1;
}
}
}
airMopOkay(mop);
return 0;
}
