static int
_nrrdFieldCheck_sizes(const Nrrd *nrrd, int useBiff) {
static const char me[]="_nrrdFieldCheck_sizes";
size_t size[NRRD_DIM_MAX];
nrrdAxisInfoGet_nva(nrrd, nrrdAxisInfoSize, size);
if (_nrrdSizeCheck(size, nrrd->dim, useBiff)) {
biffMaybeAddf(useBiff, NRRD, "%s: trouble with array sizes", me);
return 1;
}
return 0;
}
int
_nrrdFieldCheck_sizes(const Nrrd *nrrd, int useBiff) {
char me[]="_nrrdFieldCheck_sizes", err[BIFF_STRLEN];
size_t size[NRRD_DIM_MAX];
nrrdAxisInfoGet_nva(nrrd, nrrdAxisInfoSize, size);
if (_nrrdSizeCheck(size, nrrd->dim, useBiff)) {
sprintf(err, "%s: trouble with array sizes", me);
biffMaybeAdd(NRRD, err, useBiff); return 1;
}
return 0;
}
/*
******** nrrdWrap_nva()
**
** wraps a given Nrrd around a given array
**
** we don't touch any of the peripheral information (content, comments,
** blocksize, min/max) because it is entirely reasonable to be setting
** this before or after this call. "type" could be passed as
** nrrdTypeBlock, in which case it is the user's responsibility to
** set nrrd->blockSize at some other time.
*/
int
nrrdWrap_nva(Nrrd *nrrd, void *data, int type,
unsigned int dim, const size_t *size) {
char me[]="nrrdWrap_nva", err[BIFF_STRLEN];
if (!(nrrd && size)) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(NRRD, err); return 1;
}
nrrd->data = data;
nrrd->type = type;
nrrd->dim = dim;
if (_nrrdSizeCheck(size, dim, AIR_TRUE)) {
sprintf(err, "%s:", me);
biffAdd(NRRD, err); return 1;
}
nrrdAxisInfoSet_nva(nrrd, nrrdAxisInfoSize, size);
return 0;
}
/*
******** nrrdElementNumber()
**
** takes the place of old "nrrd->num": the number of elements in the
** nrrd, which is just the product of the axis sizes. A return of 0
** means there's a problem. Negative numbers are never returned.
**
** does NOT use biff
*/
size_t
nrrdElementNumber (const Nrrd *nrrd) {
size_t num, size[NRRD_DIM_MAX];
unsigned int ai;
if (!nrrd) {
return 0;
}
/* else */
nrrdAxisInfoGet_nva(nrrd, nrrdAxisInfoSize, size);
if (_nrrdSizeCheck(size, nrrd->dim, AIR_FALSE)) {
/* the nrrd's size information is invalid, can't proceed */
return 0;
}
num = 1;
for (ai=0; ai<nrrd->dim; ai++) {
/* negative numbers and overflow were caught by _nrrdSizeCheck() */
num *= size[ai];
}
return num;
}
/*
******** nrrdMaybeAlloc_nva
**
** calls nrrdAlloc_nva if the requested space is different than
** what is currently held
**
** also subscribes to the "don't mess with peripheral information" philosophy
*/
int
nrrdMaybeAlloc_nva(Nrrd *nrrd, int type,
unsigned int dim, const size_t *size)
{
char me[]="nrrdMaybeAlloc_nva", err[BIFF_STRLEN];
size_t sizeWant, sizeHave, numWant, elementSizeWant;
int need;
unsigned int ai;
if (!nrrd)
{
sprintf(err, "%s: got NULL pointer", me);
biffAdd(NRRD, err);
return 1;
}
if (airEnumValCheck(nrrdType, type))
{
sprintf(err, "%s: type (%d) is invalid", me, type);
biffAdd(NRRD, err);
return 1;
}
if (nrrdTypeBlock == type)
{
if (nrrdTypeBlock == nrrd->type)
{
sprintf(err, "%s: can't change from one block nrrd to another", me);
biffAdd(NRRD, err);
return 1;
}
if (!(0 < nrrd->blockSize))
{
sprintf(err, "%s: given nrrd->blockSize " _AIR_SIZE_T_CNV " invalid",
me, nrrd->blockSize);
biffAdd(NRRD, err);
return 1;
}
elementSizeWant = nrrd->blockSize;
}
else
{
elementSizeWant = nrrdTypeSize[type];
}
if (_nrrdSizeCheck(size, dim, AIR_TRUE))
{
sprintf(err, "%s:", me);
biffAdd(NRRD, err);
return 1;
}
if (!(nrrd->data))
{
need = 1;
}
else
{
numWant = 1;
for (ai=0; ai<dim; ai++)
{
numWant *= size[ai];
}
if (!nrrdElementSize(nrrd))
{
sprintf(err, "%s: nrrd reports zero element size!", me);
biffAdd(NRRD, err);
return 1;
}
sizeHave = nrrdElementNumber(nrrd) * nrrdElementSize(nrrd);
/* fprintf(stderr, "##%s: sizeHave = %d * %d = %d\n", me,
(int)(nrrdElementNumber(nrrd)),
(int)(nrrdElementSize(nrrd)), (int)sizeHave); */
sizeWant = numWant * elementSizeWant;
/* fprintf(stderr, "##%s: sizeWant = %d * %d = %d\n", me,
(int)(numWant),
(int)(elementSizeWant), (int)sizeWant); */
need = sizeHave != sizeWant;
/* fprintf(stderr, "##%s: need = %d\n", me, need); */
}
if (need)
{
if (nrrdAlloc_nva(nrrd, type, dim, size))
{
sprintf(err, "%s:", me);
biffAdd(NRRD, err);
return 1;
}
}
else
{
if (nrrdWrap_nva(nrrd, nrrd->data, type, dim, size))
{
sprintf(err, "%s:", me);
biffAdd(NRRD, err);
return 1;
}
/* but we do have to initialize memory! */
memset(nrrd->data, 0, nrrdElementNumber(nrrd)*nrrdElementSize(nrrd));
}
return 0;
}
