int
_miteNtxfCopy(miteRender *mrr, miteUser *muu) {
static const char me[]="_miteNtxfCopy";
int ni, E;
mrr->ntxf = AIR_CALLOC(muu->ntxfNum, Nrrd *);
if (!mrr->ntxf) {
biffAddf(MITE, "%s: couldn't calloc %d ntxf pointers", me, muu->ntxfNum);
return 1;
}
mrr->ntxfNum = muu->ntxfNum;
airMopAdd(mrr->rmop, mrr->ntxf, airFree, airMopAlways);
E = 0;
for (ni=0; ni<mrr->ntxfNum; ni++) {
mrr->ntxf[ni] = nrrdNew();
if (!E) airMopAdd(mrr->rmop, mrr->ntxf[ni],
(airMopper)nrrdNuke, airMopAlways);
if (!( nrrdTypeUChar == muu->ntxf[ni]->type
|| nrrdTypeFloat == muu->ntxf[ni]->type
|| nrrdTypeDouble == muu->ntxf[ni]->type )) {
biffAddf(MITE,
"%s: sorry, can't handle txf of type %s (only %s, %s, %s)",
me, airEnumStr(nrrdType, muu->ntxf[ni]->type),
airEnumStr(nrrdType, nrrdTypeUChar),
airEnumStr(nrrdType, nrrdTypeFloat),
airEnumStr(nrrdType, nrrdTypeDouble));
return 1;
}
/* note that key/values need to be copied for the sake of
identifying a non-default miteStageOp */
switch(muu->ntxf[ni]->type) {
case nrrdTypeUChar:
if (!E) E |= nrrdUnquantize(mrr->ntxf[ni], muu->ntxf[ni], nrrdTypeUChar);
if (!E) E |= nrrdKeyValueCopy(mrr->ntxf[ni], muu->ntxf[ni]);
break;
case mite_nt:
if (!E) E |= nrrdCopy(mrr->ntxf[ni], muu->ntxf[ni]);
break;
default: /* will be either float or double (whatever mite_nt isn't) */
if (!E) E |= nrrdConvert(mrr->ntxf[ni], muu->ntxf[ni], mite_nt);
if (!E) E |= nrrdKeyValueCopy(mrr->ntxf[ni], muu->ntxf[ni]);
break;
}
}
if (E) {
biffMovef(MITE, NRRD, "%s: troubling copying/converting all ntxfs", me);
return 1;
}
return 0;
}
int
main() {
airArray *mop, *submop;
char *err;
int typi;
unsigned int supi, probePass, cti /* context copy index */,
pvlIdx[NRRD_TYPE_MAX+1], sx, sy, sz, subnum;
size_t sizes[3] = {42,61,50} /* one of these must be even */,
ii, nn;
Nrrd *norigScl, *nucharScl, *nunquant, *nqdiff,
*nconvScl[NRRD_TYPE_MAX+1];
unsigned char *ucharScl;
gageContext *gctx[2][KERN_SIZE_MAX+1];
gagePerVolume *gpvl[2][NRRD_TYPE_MAX+1][KERN_SIZE_MAX+1];
const double *vansScl[2][NRRD_TYPE_MAX+1][KERN_SIZE_MAX+1],
*gansScl[2][NRRD_TYPE_MAX+1][KERN_SIZE_MAX+1],
*hansScl[2][NRRD_TYPE_MAX+1][KERN_SIZE_MAX+1];
double *origScl, omin, omax, dsx, dsy, dsz,
spcOrig[NRRD_SPACE_DIM_MAX] = {0.0, 0.0, 0.0},
spcVec[3][NRRD_SPACE_DIM_MAX] = {
{1.1, 0.0, 0.0},
{0.0, 2.2, 0.0},
{0.0, 0.0, 3.3}};
mop = airMopNew();
#define NRRD_NEW(name, mop) \
(name) = nrrdNew(); \
airMopAdd((mop), (name), (airMopper)nrrdNuke, airMopAlways)
/* --------------------------------------------------------------- */
/* Creating initial volume */
NRRD_NEW(norigScl, mop);
if (nrrdMaybeAlloc_nva(norigScl, nrrdTypeDouble, 3, sizes)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "trouble allocating:\n%s", err);
airMopError(mop); return 1;
}
origScl = AIR_CAST(double *, norigScl->data);
nn = nrrdElementNumber(norigScl);
airSrandMT(42*42);
for (ii=0; ii<nn/2; ii++) {
airNormalRand(origScl + 2*ii + 0, origScl + 2*ii + 1);
}
/* learn real range */
omin = omax = origScl[0];
for (ii=1; ii<nn; ii++) {
omin = AIR_MIN(omin, origScl[ii]);
omax = AIR_MAX(omax, origScl[ii]);
}
ELL_3V_SET(spcOrig, 0.0, 0.0, 0.0);
if (nrrdSpaceSet(norigScl, nrrdSpaceRightAnteriorSuperior)
|| nrrdSpaceOriginSet(norigScl, spcOrig)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "trouble setting space:\n%s", err);
airMopError(mop); return 1;
}
nrrdAxisInfoSet_nva(norigScl, nrrdAxisInfoSpaceDirection, spcVec);
dsx = AIR_CAST(double, sizes[0]);
dsy = AIR_CAST(double, sizes[1]);
dsz = AIR_CAST(double, sizes[2]);
sx = AIR_CAST(unsigned int, sizes[0]);
sy = AIR_CAST(unsigned int, sizes[1]);
sz = AIR_CAST(unsigned int, sizes[2]);
subnum = AIR_CAST(unsigned int, PROBE_NUM*0.9);
/* --------------------------------------------------------------- */
/* Quantizing to 8-bits and checking */
submop = airMopNew();
NRRD_NEW(nucharScl, mop);
NRRD_NEW(nunquant, submop);
NRRD_NEW(nqdiff, submop);
if (nrrdQuantize(nucharScl, norigScl, NULL, 8)
|| nrrdUnquantize(nunquant, nucharScl, nrrdTypeDouble)
|| nrrdArithBinaryOp(nqdiff, nrrdBinaryOpSubtract,
norigScl, nunquant)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "trouble quantizing and back:\n%s", err);
airMopError(submop); airMopError(mop); return 1;
}
if (!( nucharScl->oldMin == omin
&& nucharScl->oldMax == omax )) {
fprintf(stderr, "quantization range [%g,%g] != real range [%g,%g]\n",
nucharScl->oldMin, nucharScl->oldMax, omin, omax);
airMopError(submop); airMopError(mop); return 1;
}
{
double *qdiff, *unquant;
/* empirically determined tolerance, which had to be increased in
order to work under valgrind (!)- perhaps because of a
difference in the use of 80-bit registers */
double epsilon=0.50000000000004;
qdiff = AIR_CAST(double *, nqdiff->data);
unquant = AIR_CAST(double *, nunquant->data);
for (ii=0; ii<nn; ii++) {
double dd;
/* with infinite precision, the max difference between original and
quantized values should be exactly half the width (in value)
of 1/256 of value range ==> dd = 0.5 */
dd = qdiff[ii]*256/(omax - omin);
if (AIR_ABS(dd) > epsilon) {
unsigned int ui;
ui = AIR_CAST(unsigned int, ii);
fprintf(stderr, "|orig[%u]=%.17g - unquant=%.17g|*256/%.17g "
"= %.17g > %.17g!\n", ui, origScl[ii], unquant[ii],
omax - omin, AIR_ABS(dd), epsilon);
airMopError(submop); airMopError(mop); return 1;
}
}
}
